From a508cfd9be1564976fac6512066f01f1113402fa Mon Sep 17 00:00:00 2001
From: unknown <chengshaofei@sh-chengshf01.SNDA.ROOT.CORP>
Date: Fri, 19 Oct 2012 09:57:15 +0800
Subject: [PATCH] a static analysis tool

---
 samples/Variable.html       |    173 +
 samples/Visualizer.html     |      2 +-
 source/SyntacticalParser.js |      8 +-
 test/ext-all-debug.js       | 113993 +++++++++++++++++++++++++++++++++
 test/ext-all.js             |     38 +
 test/jquery-1.8.2.js        |   9440 +++
 test/jquery-1.8.2.min.js    |      2 +
 7 files changed, 123651 insertions(+), 5 deletions(-)
 create mode 100644 samples/Variable.html
 create mode 100644 test/ext-all-debug.js
 create mode 100644 test/ext-all.js
 create mode 100644 test/jquery-1.8.2.js
 create mode 100644 test/jquery-1.8.2.min.js
diff --git a/samples/Variable.html b/samples/Variable.html
new file mode 100644
index 0000000..6044c63
--- /dev/null
+++ b/samples/Variable.html
@@ -0,0 +1,173 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="UTF-8" />
+<title>javascript grammar tree preprocessr</title>
+<style>
+.symbolName {
+    display:block;
+}
+.childContainer {
+    padding-left:30px;
+}
+</style>
+<script src="../source/LexicalParser.js"></script>
+<script src="../source/SyntacticalParser.js"></script>
+<script src="../source/Parser.js"></script>
+<script>
+
+var preprocessors = {
+    "VariableDeclarationListNoIn":preprocessVariable,
+    "VariableDeclarationList":preprocessVariable,
+    "FunctionDeclaration":preprocessFunctionDeclaration,
+    "FunctionExpression":preprocessFunctionExpression
+}
+var processors = {
+    "FunctionDeclaration":processFunctionDeclaration,
+    "FunctionExpression":processFunctionExpression,
+    "FunctionBody":processCode,
+    "Program":processCode,
+    "FormalParameterList":processParameter,
+    "Identifier":processIdentifier
+}
+
+function preprocessVariable(scope,node) {
+    var i = node.childNodes.length;
+    scope.addIdentifier(node.childNodes[0].childNodes[node.childNodes[0].childNodes.length-1].token.toString());
+    while(i--) {
+        preprocess(scope,node.childNodes[i]);
+    }
+}
+
+function preprocessFunctionDeclaration(scope,node) {    
+    var i = node.childNodes.length;
+    while(i--){
+        if(node.childNodes[i].name == "Identifier") {
+            scope.addIdentifier(node.childNodes[i].token.toString());
+        }
+    }
+}
+function preprocessFunctionExpression(scope,node) {    
+
+}
+function preprocessCode(scope,node) {
+    var i = node.childNodes.length;
+    while(i--)preprocess(scope,node.childNodes[i]);
+}
+
+function preprocess(scope,node) {
+    if(preprocessors[node.name]) return preprocessors[node.name](scope,node);
+
+    var i = node.childNodes.length;
+    while(i--)preprocess(scope,node.childNodes[i]);
+}
+
+function processParameter(scope,node) {
+    var i = node.childNodes.length;
+    while(i--) {
+        if(node.childNodes[i].token)
+            scope.addIdentifier(node.childNodes[i].token.toString());
+        else
+            preprocessParameter(node.childNodes[i]);
+    }
+}
+function processFunctionExpression(scope,node) {
+    scope = new Scope(scope);
+    var i = node.childNodes.length;
+    while(i--){
+        if(node.childNodes[i].name == "Identifier") {
+            scope.addIdentifier(node.childNodes[i].token.toString());
+        }
+    }
+    scope = new Scope(scope);
+    
+    var i = node.childNodes.length;
+    while(i--){
+        if(node.childNodes[i].name == "FormalParameterList") {
+            process(scope,node.childNodes[i]);
+        }        
+    }
+    var i = node.childNodes.length;
+    while(i--){
+        if(node.childNodes[i].name == "FunctionBody") {
+            process(scope,node.childNodes[i]);
+        }        
+    }
+}
+function processFunctionDeclaration(scope,node) {
+    scope = new Scope(scope);    
+    var i = node.childNodes.length;
+    while(i--){
+        if(node.childNodes[i].name == "FormalParameterList") {
+            process(scope,node.childNodes[i]);
+        }        
+    }
+    var i = node.childNodes.length;
+    while(i--){
+        if(node.childNodes[i].name == "FunctionBody") {
+            process(scope,node.childNodes[i]);
+        }
+    }
+}
+function processIdentifier(scope,node) {
+    scope.accessIdentifier(node.token.toString());
+}
+function processCode(scope,node) {
+    preprocess(scope,node);
+    var i = node.childNodes.length;
+    while(i--)process(scope,node.childNodes[i]);
+}
+function process(scope,node) {
+    if(processors[node.name]) return processors[node.name](scope,node);
+    var i = node.childNodes.length;
+    while(i--)process(scope,node.childNodes[i]);
+} 
+
+function Scope(parent){
+
+    this.parent = parent || null;
+
+    var table = Object.create(null);
+
+    this.accessIdentifier = function(id){
+        if(!this.parent) {
+            table[id] = undefined;
+        }
+        else if(!Object.prototype.hasOwnProperty.call(table,id)) {
+            this.parent.accessIdentifier(id);
+        }
+    }
+    this.addIdentifier = function(id){
+        table[id] = undefined;
+    }
+    this.toString = function(){
+        return table;
+    }
+}
+
+window.onload = function(){
+    
+    document.querySelector("button").onclick = function(){
+        try {
+            var parser = new Parser();
+            preprocessr.innerHTML = "";
+            var tree = parser.parse(document.querySelector("#code").value);
+            var o = new Scope();
+            process(o,tree);
+            console.log(o.toString());
+        } catch(e) {
+            preprocessr.innerHTML = "<span style=\"color:red;\">"+e+"</span>"
+        }
+    }
+}
+</script>
+</head>
+<body>
+<textarea id="code" style="width:100%;height:500px;"></textarea>
+<button >parse</button>
+    <div id="preprocessr">
+
+    </div>
+    
+</body>
+</html>
\ No newline at end of file
diff --git a/samples/Visualizer.html b/samples/Visualizer.html
index dd6322c..d7a5785 100644
--- a/samples/Visualizer.html
+++ b/samples/Visualizer.html
@@ -12,7 +12,7 @@
 }
 </style>
 <script src="../source/LexicalParser.js"></script>
-<script src="../source/SyntaticalParser.js"></script>
+<script src="../source/SyntacticalParser.js"></script>
 <script src="../source/Parser.js"></script>
 <script>
 
diff --git a/source/SyntacticalParser.js b/source/SyntacticalParser.js
index 490e8c3..90ca740 100644
--- a/source/SyntacticalParser.js
+++ b/source/SyntacticalParser.js
@@ -72,11 +72,11 @@
     "Catch":[["catch", "(", "Identifier", ")", "Block"]], 
     "Finally":[["finally", "Block"]], 
     "DebuggerStatement":[["debugger", ";"]], 
-    "FunctionDeclaration":[["function", "Identifier", "(", "FormalParameterList", ")", "{", "FunctionBody", "}"], ["function", "Identifier", "(", ")", "{", "FunctionBody", "}"]], 
-    "FunctionExpression":[["function", "Identifier", "(", "FormalParameterList", ")", "{", "FunctionBody", "}"], ["function", "(", "FormalParameterList", ")", "{", "FunctionBody", "}"], ["function", "Identifier", "(", ")", "{", "FunctionBody", "}"], ["function", "(", ")", "{", "FunctionBody", "}"]], 
+    "FunctionDeclaration":[["function", "Identifier", "(", "FormalParameterList", ")", "{", "FunctionBody", "}"],["function", "Identifier", "(", "FormalParameterList", ")", "{", "}"], ["function", "Identifier", "(", ")", "{", "FunctionBody", "}"], ["function", "Identifier", "(", ")", "{", "}"]], 
+    "FunctionExpression":[["function", "Identifier", "(", "FormalParameterList", ")", "{", "FunctionBody", "}"], ["function", "(", "FormalParameterList", ")", "{", "FunctionBody", "}"], ["function", "Identifier", "(", ")", "{", "FunctionBody", "}"], ["function", "(", ")", "{", "FunctionBody", "}"],  ["function", "Identifier", "(", "FormalParameterList", ")", "{", "}"], ["function", "(", "FormalParameterList", ")", "{", "}"], ["function", "Identifier", "(", ")", "{", "}"], ["function", "(", ")", "{", "}"]], 
     "FormalParameterList":[["Identifier"], ["FormalParameterList", ",", "Identifier"]], 
-    "FunctionBody":[["SourceElements"], [""]], 
-    "Program":[["SourceElements"], [""]], 
+    "FunctionBody":[["SourceElements"]], 
+    "Program":[["SourceElements"]], 
     "SourceElements":[["SourceElement"], ["SourceElements", "SourceElement"]], "SourceElement":[["Statement"], ["FunctionDeclaration"]]
     
 };
diff --git a/test/ext-all-debug.js b/test/ext-all-debug.js
new file mode 100644
index 0000000..fa83337
--- /dev/null
+++ b/test/ext-all-debug.js
@@ -0,0 +1,113993 @@
+/*
+Ext JS 4.1 - JavaScript Library
+Copyright (c) 2006-2012, Sencha Inc.
+All rights reserved.
+licensing@sencha.com
+
+http://www.sencha.com/license
+
+Open Source License
+------------------------------------------------------------------------------------------
+This version of Ext JS is licensed under the terms of the Open Source GPL 3.0 license. 
+
+http://www.gnu.org/licenses/gpl.html
+
+There are several FLOSS exceptions available for use with this release for
+open source applications that are distributed under a license other than GPL.
+
+* Open Source License Exception for Applications
+
+  http://www.sencha.com/products/floss-exception.php
+
+* Open Source License Exception for Development
+
+  http://www.sencha.com/products/ux-exception.php
+
+
+Alternate Licensing
+------------------------------------------------------------------------------------------
+Commercial and OEM Licenses are available for an alternate download of Ext JS.
+This is the appropriate option if you are creating proprietary applications and you are 
+not prepared to distribute and share the source code of your application under the 
+GPL v3 license. Please visit http://www.sencha.com/license for more details.
+
+--
+
+This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT OF THIRD-PARTY INTELLECTUAL PROPERTY RIGHTS.  See the GNU General Public License for more details.
+*/
+//@tag foundation,core
+
+
+var Ext = Ext || {};
+Ext._startTime = new Date().getTime();
+(function() {
+    var global = this,
+        objectPrototype = Object.prototype,
+        toString = objectPrototype.toString,
+        enumerables = true,
+        enumerablesTest = { toString: 1 },
+        emptyFn = function () {},
+        
+        
+        callOverrideParent = function () {
+            var method = callOverrideParent.caller.caller; 
+            return method.$owner.prototype[method.$name].apply(this, arguments);
+        },
+        i;
+
+    Ext.global = global;
+
+    for (i in enumerablesTest) {
+        enumerables = null;
+    }
+
+    if (enumerables) {
+        enumerables = ['hasOwnProperty', 'valueOf', 'isPrototypeOf', 'propertyIsEnumerable',
+                       'toLocaleString', 'toString', 'constructor'];
+    }
+
+    
+    Ext.enumerables = enumerables;
+
+    
+    Ext.apply = function(object, config, defaults) {
+        if (defaults) {
+            Ext.apply(object, defaults);
+        }
+
+        if (object && config && typeof config === 'object') {
+            var i, j, k;
+
+            for (i in config) {
+                object[i] = config[i];
+            }
+
+            if (enumerables) {
+                for (j = enumerables.length; j--;) {
+                    k = enumerables[j];
+                    if (config.hasOwnProperty(k)) {
+                        object[k] = config[k];
+                    }
+                }
+            }
+        }
+
+        return object;
+    };
+
+    Ext.buildSettings = Ext.apply({
+        baseCSSPrefix: 'x-',
+        scopeResetCSS: false
+    }, Ext.buildSettings || {});
+
+    Ext.apply(Ext, {
+
+        
+        name: Ext.sandboxName || 'Ext',
+
+        
+        emptyFn: emptyFn,
+
+        
+        emptyString: new String(),
+
+        baseCSSPrefix: Ext.buildSettings.baseCSSPrefix,
+
+        
+        applyIf: function(object, config) {
+            var property;
+
+            if (object) {
+                for (property in config) {
+                    if (object[property] === undefined) {
+                        object[property] = config[property];
+                    }
+                }
+            }
+
+            return object;
+        },
+
+        
+        iterate: function(object, fn, scope) {
+            if (Ext.isEmpty(object)) {
+                return;
+            }
+
+            if (scope === undefined) {
+                scope = object;
+            }
+
+            if (Ext.isIterable(object)) {
+                Ext.Array.each.call(Ext.Array, object, fn, scope);
+            }
+            else {
+                Ext.Object.each.call(Ext.Object, object, fn, scope);
+            }
+        }
+    });
+
+    Ext.apply(Ext, {
+
+        
+        extend: (function() {
+            
+            var objectConstructor = objectPrototype.constructor,
+                inlineOverrides = function(o) {
+                for (var m in o) {
+                    if (!o.hasOwnProperty(m)) {
+                        continue;
+                    }
+                    this[m] = o[m];
+                }
+            };
+
+            return function(subclass, superclass, overrides) {
+                
+                if (Ext.isObject(superclass)) {
+                    overrides = superclass;
+                    superclass = subclass;
+                    subclass = overrides.constructor !== objectConstructor ? overrides.constructor : function() {
+                        superclass.apply(this, arguments);
+                    };
+                }
+
+
+                
+                var F = function() {},
+                    subclassProto, superclassProto = superclass.prototype;
+
+                F.prototype = superclassProto;
+                subclassProto = subclass.prototype = new F();
+                subclassProto.constructor = subclass;
+                subclass.superclass = superclassProto;
+
+                if (superclassProto.constructor === objectConstructor) {
+                    superclassProto.constructor = superclass;
+                }
+
+                subclass.override = function(overrides) {
+                    Ext.override(subclass, overrides);
+                };
+
+                subclassProto.override = inlineOverrides;
+                subclassProto.proto = subclassProto;
+
+                subclass.override(overrides);
+                subclass.extend = function(o) {
+                    return Ext.extend(subclass, o);
+                };
+
+                return subclass;
+            };
+        }()),
+
+        
+        override: function (target, overrides) {
+            if (target.$isClass) {
+                target.override(overrides);
+            } else if (typeof target == 'function') {
+                Ext.apply(target.prototype, overrides);
+            } else {
+                var owner = target.self,
+                    name, value;
+
+                if (owner && owner.$isClass) { 
+                    for (name in overrides) {
+                        if (overrides.hasOwnProperty(name)) {
+                            value = overrides[name];
+
+                            if (typeof value == 'function') {
+
+                                value.$name = name;
+                                value.$owner = owner;
+                                value.$previous = target.hasOwnProperty(name)
+                                    ? target[name] 
+                                    : callOverrideParent; 
+                            }
+
+                            target[name] = value;
+                        }
+                    }
+                } else {
+                    Ext.apply(target, overrides);
+                }
+            }
+
+            return target;
+        }
+    });
+
+    
+    Ext.apply(Ext, {
+
+        
+        valueFrom: function(value, defaultValue, allowBlank){
+            return Ext.isEmpty(value, allowBlank) ? defaultValue : value;
+        },
+
+        
+        typeOf: function(value) {
+            var type,
+                typeToString;
+            
+            if (value === null) {
+                return 'null';
+            }
+
+            type = typeof value;
+
+            if (type === 'undefined' || type === 'string' || type === 'number' || type === 'boolean') {
+                return type;
+            }
+
+            typeToString = toString.call(value);
+
+            switch(typeToString) {
+                case '[object Array]':
+                    return 'array';
+                case '[object Date]':
+                    return 'date';
+                case '[object Boolean]':
+                    return 'boolean';
+                case '[object Number]':
+                    return 'number';
+                case '[object RegExp]':
+                    return 'regexp';
+            }
+
+            if (type === 'function') {
+                return 'function';
+            }
+
+            if (type === 'object') {
+                if (value.nodeType !== undefined) {
+                    if (value.nodeType === 3) {
+                        return (/\S/).test(value.nodeValue) ? 'textnode' : 'whitespace';
+                    }
+                    else {
+                        return 'element';
+                    }
+                }
+
+                return 'object';
+            }
+
+        },
+
+        
+        isEmpty: function(value, allowEmptyString) {
+            return (value === null) || (value === undefined) || (!allowEmptyString ? value === '' : false) || (Ext.isArray(value) && value.length === 0);
+        },
+
+        
+        isArray: ('isArray' in Array) ? Array.isArray : function(value) {
+            return toString.call(value) === '[object Array]';
+        },
+
+        
+        isDate: function(value) {
+            return toString.call(value) === '[object Date]';
+        },
+
+        
+        isObject: (toString.call(null) === '[object Object]') ?
+        function(value) {
+            
+            return value !== null && value !== undefined && toString.call(value) === '[object Object]' && value.ownerDocument === undefined;
+        } :
+        function(value) {
+            return toString.call(value) === '[object Object]';
+        },
+
+        
+        isSimpleObject: function(value) {
+            return value instanceof Object && value.constructor === Object;
+        },
+        
+        isPrimitive: function(value) {
+            var type = typeof value;
+
+            return type === 'string' || type === 'number' || type === 'boolean';
+        },
+
+        
+        isFunction:
+        
+        
+        (typeof document !== 'undefined' && typeof document.getElementsByTagName('body') === 'function') ? function(value) {
+            return toString.call(value) === '[object Function]';
+        } : function(value) {
+            return typeof value === 'function';
+        },
+
+        
+        isNumber: function(value) {
+            return typeof value === 'number' && isFinite(value);
+        },
+
+        
+        isNumeric: function(value) {
+            return !isNaN(parseFloat(value)) && isFinite(value);
+        },
+
+        
+        isString: function(value) {
+            return typeof value === 'string';
+        },
+
+        
+        isBoolean: function(value) {
+            return typeof value === 'boolean';
+        },
+
+        
+        isElement: function(value) {
+            return value ? value.nodeType === 1 : false;
+        },
+
+        
+        isTextNode: function(value) {
+            return value ? value.nodeName === "#text" : false;
+        },
+
+        
+        isDefined: function(value) {
+            return typeof value !== 'undefined';
+        },
+
+        
+        isIterable: function(value) {
+            var type = typeof value,
+                checkLength = false;
+            if (value && type != 'string') {
+                
+                if (type == 'function') {
+                    
+                    
+                    if (Ext.isSafari) {
+                        checkLength = value instanceof NodeList || value instanceof HTMLCollection;
+                    }
+                } else {
+                    checkLength = true;
+                }
+            }
+            return checkLength ? value.length !== undefined : false;
+        }
+    });
+
+    Ext.apply(Ext, {
+
+        
+        clone: function(item) {
+            var type,
+                i,
+                j,
+                k,
+                clone,
+                key;
+            
+            if (item === null || item === undefined) {
+                return item;
+            }
+
+            
+            
+            
+            if (item.nodeType && item.cloneNode) {
+                return item.cloneNode(true);
+            }
+
+            type = toString.call(item);
+
+            
+            if (type === '[object Date]') {
+                return new Date(item.getTime());
+            }
+
+
+            
+            if (type === '[object Array]') {
+                i = item.length;
+
+                clone = [];
+
+                while (i--) {
+                    clone[i] = Ext.clone(item[i]);
+                }
+            }
+            
+            else if (type === '[object Object]' && item.constructor === Object) {
+                clone = {};
+
+                for (key in item) {
+                    clone[key] = Ext.clone(item[key]);
+                }
+
+                if (enumerables) {
+                    for (j = enumerables.length; j--;) {
+                        k = enumerables[j];
+                        clone[k] = item[k];
+                    }
+                }
+            }
+
+            return clone || item;
+        },
+
+        
+        getUniqueGlobalNamespace: function() {
+            var uniqueGlobalNamespace = this.uniqueGlobalNamespace,
+                i;
+
+            if (uniqueGlobalNamespace === undefined) {
+                i = 0;
+
+                do {
+                    uniqueGlobalNamespace = 'ExtBox' + (++i);
+                } while (Ext.global[uniqueGlobalNamespace] !== undefined);
+
+                Ext.global[uniqueGlobalNamespace] = Ext;
+                this.uniqueGlobalNamespace = uniqueGlobalNamespace;
+            }
+
+            return uniqueGlobalNamespace;
+        },
+        
+        
+        functionFactoryCache: {},
+        
+        cacheableFunctionFactory: function() {
+            var me = this,
+                args = Array.prototype.slice.call(arguments),
+                cache = me.functionFactoryCache,
+                idx, fn, ln;
+                
+             if (Ext.isSandboxed) {
+                ln = args.length;
+                if (ln > 0) {
+                    ln--;
+                    args[ln] = 'var Ext=window.' + Ext.name + ';' + args[ln];
+                }
+            }
+            idx = args.join('');
+            fn = cache[idx];
+            if (!fn) {
+                fn = Function.prototype.constructor.apply(Function.prototype, args);
+                
+                cache[idx] = fn;
+            }
+            return fn;
+        },
+        
+        functionFactory: function() {
+            var me = this,
+                args = Array.prototype.slice.call(arguments),
+                ln;
+                
+            if (Ext.isSandboxed) {
+                ln = args.length;
+                if (ln > 0) {
+                    ln--;
+                    args[ln] = 'var Ext=window.' + Ext.name + ';' + args[ln];
+                }
+            }
+     
+            return Function.prototype.constructor.apply(Function.prototype, args);
+        },
+
+        
+        Logger: {
+            verbose: emptyFn,
+            log: emptyFn,
+            info: emptyFn,
+            warn: emptyFn,
+            error: function(message) {
+                throw new Error(message);
+            },
+            deprecate: emptyFn
+        }
+    });
+
+    
+    Ext.type = Ext.typeOf;
+
+}());
+
+
+Ext.globalEval = Ext.global.execScript
+    ? function(code) {
+        execScript(code);
+    }
+    : function($$code) {
+        
+        
+        (function(){
+            eval($$code);
+        }());
+    };
+
+//@tag foundation,core
+
+//@require ../Ext.js
+
+
+
+(function() {
+
+
+var version = '4.1.1.1', Version;
+    Ext.Version = Version = Ext.extend(Object, {
+
+        
+        constructor: function(version) {
+            var parts, releaseStartIndex;
+
+            if (version instanceof Version) {
+                return version;
+            }
+
+            this.version = this.shortVersion = String(version).toLowerCase().replace(/_/g, '.').replace(/[\-+]/g, '');
+
+            releaseStartIndex = this.version.search(/([^\d\.])/);
+
+            if (releaseStartIndex !== -1) {
+                this.release = this.version.substr(releaseStartIndex, version.length);
+                this.shortVersion = this.version.substr(0, releaseStartIndex);
+            }
+
+            this.shortVersion = this.shortVersion.replace(/[^\d]/g, '');
+
+            parts = this.version.split('.');
+
+            this.major = parseInt(parts.shift() || 0, 10);
+            this.minor = parseInt(parts.shift() || 0, 10);
+            this.patch = parseInt(parts.shift() || 0, 10);
+            this.build = parseInt(parts.shift() || 0, 10);
+
+            return this;
+        },
+
+        
+        toString: function() {
+            return this.version;
+        },
+
+        
+        valueOf: function() {
+            return this.version;
+        },
+
+        
+        getMajor: function() {
+            return this.major || 0;
+        },
+
+        
+        getMinor: function() {
+            return this.minor || 0;
+        },
+
+        
+        getPatch: function() {
+            return this.patch || 0;
+        },
+
+        
+        getBuild: function() {
+            return this.build || 0;
+        },
+
+        
+        getRelease: function() {
+            return this.release || '';
+        },
+
+        
+        isGreaterThan: function(target) {
+            return Version.compare(this.version, target) === 1;
+        },
+
+        
+        isGreaterThanOrEqual: function(target) {
+            return Version.compare(this.version, target) >= 0;
+        },
+
+        
+        isLessThan: function(target) {
+            return Version.compare(this.version, target) === -1;
+        },
+
+        
+        isLessThanOrEqual: function(target) {
+            return Version.compare(this.version, target) <= 0;
+        },
+
+        
+        equals: function(target) {
+            return Version.compare(this.version, target) === 0;
+        },
+
+        
+        match: function(target) {
+            target = String(target);
+            return this.version.substr(0, target.length) === target;
+        },
+
+        
+        toArray: function() {
+            return [this.getMajor(), this.getMinor(), this.getPatch(), this.getBuild(), this.getRelease()];
+        },
+
+        
+        getShortVersion: function() {
+            return this.shortVersion;
+        },
+
+        
+        gt: function() {
+            return this.isGreaterThan.apply(this, arguments);
+        },
+
+        
+        lt: function() {
+            return this.isLessThan.apply(this, arguments);
+        },
+
+        
+        gtEq: function() {
+            return this.isGreaterThanOrEqual.apply(this, arguments);
+        },
+
+        
+        ltEq: function() {
+            return this.isLessThanOrEqual.apply(this, arguments);
+        }
+    });
+
+    Ext.apply(Version, {
+        
+        releaseValueMap: {
+            'dev': -6,
+            'alpha': -5,
+            'a': -5,
+            'beta': -4,
+            'b': -4,
+            'rc': -3,
+            '#': -2,
+            'p': -1,
+            'pl': -1
+        },
+
+        
+        getComponentValue: function(value) {
+            return !value ? 0 : (isNaN(value) ? this.releaseValueMap[value] || value : parseInt(value, 10));
+        },
+
+        
+        compare: function(current, target) {
+            var currentValue, targetValue, i;
+
+            current = new Version(current).toArray();
+            target = new Version(target).toArray();
+
+            for (i = 0; i < Math.max(current.length, target.length); i++) {
+                currentValue = this.getComponentValue(current[i]);
+                targetValue = this.getComponentValue(target[i]);
+
+                if (currentValue < targetValue) {
+                    return -1;
+                } else if (currentValue > targetValue) {
+                    return 1;
+                }
+            }
+
+            return 0;
+        }
+    });
+
+    
+    Ext.apply(Ext, {
+        
+        versions: {},
+
+        
+        lastRegisteredVersion: null,
+
+        
+        setVersion: function(packageName, version) {
+            Ext.versions[packageName] = new Version(version);
+            Ext.lastRegisteredVersion = Ext.versions[packageName];
+
+            return this;
+        },
+
+        
+        getVersion: function(packageName) {
+            if (packageName === undefined) {
+                return Ext.lastRegisteredVersion;
+            }
+
+            return Ext.versions[packageName];
+        },
+
+        
+        deprecate: function(packageName, since, closure, scope) {
+            if (Version.compare(Ext.getVersion(packageName), since) < 1) {
+                closure.call(scope);
+            }
+        }
+    }); 
+
+    Ext.setVersion('core', version);
+
+}());
+
+//@tag foundation,core
+
+//@require ../version/Version.js
+
+
+
+
+Ext.String = (function() {
+    var trimRegex     = /^[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]+|[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]+$/g,
+        escapeRe      = /('|\\)/g,
+        formatRe      = /\{(\d+)\}/g,
+        escapeRegexRe = /([-.*+?\^${}()|\[\]\/\\])/g,
+        basicTrimRe   = /^\s+|\s+$/g,
+        whitespaceRe  = /\s+/,
+        varReplace    = /(^[^a-z]*|[^\w])/gi,
+        charToEntity,
+        entityToChar,
+        charToEntityRegex,
+        entityToCharRegex,
+        htmlEncodeReplaceFn = function(match, capture) {
+            return charToEntity[capture];
+        },
+        htmlDecodeReplaceFn = function(match, capture) {
+            return (capture in entityToChar) ? entityToChar[capture] : String.fromCharCode(parseInt(capture.substr(2), 10));
+        };
+
+    return {
+
+        
+        createVarName: function(s) {
+            return s.replace(varReplace, '');
+        },
+
+        
+        htmlEncode: function(value) {
+            return (!value) ? value : String(value).replace(charToEntityRegex, htmlEncodeReplaceFn);
+        },
+
+        
+        htmlDecode: function(value) {
+            return (!value) ? value : String(value).replace(entityToCharRegex, htmlDecodeReplaceFn);
+        },
+
+        
+        addCharacterEntities: function(newEntities) {
+            var charKeys = [],
+                entityKeys = [],
+                key, echar;
+            for (key in newEntities) {
+                echar = newEntities[key];
+                entityToChar[key] = echar;
+                charToEntity[echar] = key;
+                charKeys.push(echar);
+                entityKeys.push(key);
+            }
+            charToEntityRegex = new RegExp('(' + charKeys.join('|') + ')', 'g');
+            entityToCharRegex = new RegExp('(' + entityKeys.join('|') + '|&#[0-9]{1,5};' + ')', 'g');
+        },
+
+        
+        resetCharacterEntities: function() {
+            charToEntity = {};
+            entityToChar = {};
+            
+            this.addCharacterEntities({
+                '&amp;'     :   '&',
+                '&gt;'      :   '>',
+                '&lt;'      :   '<',
+                '&quot;'    :   '"',
+                '&#39;'     :   "'"
+            });
+        },
+
+        
+        urlAppend : function(url, string) {
+            if (!Ext.isEmpty(string)) {
+                return url + (url.indexOf('?') === -1 ? '?' : '&') + string;
+            }
+
+            return url;
+        },
+
+        
+        trim: function(string) {
+            return string.replace(trimRegex, "");
+        },
+
+        
+        capitalize: function(string) {
+            return string.charAt(0).toUpperCase() + string.substr(1);
+        },
+
+        
+        uncapitalize: function(string) {
+            return string.charAt(0).toLowerCase() + string.substr(1);
+        },
+
+        
+        ellipsis: function(value, len, word) {
+            if (value && value.length > len) {
+                if (word) {
+                    var vs = value.substr(0, len - 2),
+                    index = Math.max(vs.lastIndexOf(' '), vs.lastIndexOf('.'), vs.lastIndexOf('!'), vs.lastIndexOf('?'));
+                    if (index !== -1 && index >= (len - 15)) {
+                        return vs.substr(0, index) + "...";
+                    }
+                }
+                return value.substr(0, len - 3) + "...";
+            }
+            return value;
+        },
+
+        
+        escapeRegex: function(string) {
+            return string.replace(escapeRegexRe, "\\$1");
+        },
+
+        
+        escape: function(string) {
+            return string.replace(escapeRe, "\\$1");
+        },
+
+        
+        toggle: function(string, value, other) {
+            return string === value ? other : value;
+        },
+
+        
+        leftPad: function(string, size, character) {
+            var result = String(string);
+            character = character || " ";
+            while (result.length < size) {
+                result = character + result;
+            }
+            return result;
+        },
+
+        
+        format: function(format) {
+            var args = Ext.Array.toArray(arguments, 1);
+            return format.replace(formatRe, function(m, i) {
+                return args[i];
+            });
+        },
+
+        
+        repeat: function(pattern, count, sep) {
+            for (var buf = [], i = count; i--; ) {
+                buf.push(pattern);
+            }
+            return buf.join(sep || '');
+        },
+
+        
+        splitWords: function (words) {
+            if (words && typeof words == 'string') {
+                return words.replace(basicTrimRe, '').split(whitespaceRe);
+            }
+            return words || [];
+        }
+    };
+}());
+
+
+Ext.String.resetCharacterEntities();
+
+
+Ext.htmlEncode = Ext.String.htmlEncode;
+
+
+
+Ext.htmlDecode = Ext.String.htmlDecode;
+
+
+Ext.urlAppend = Ext.String.urlAppend;
+
+//@tag foundation,core
+
+//@require String.js
+
+//@define Ext.Number
+
+
+
+
+Ext.Number = new function() {
+
+    var me = this,
+        isToFixedBroken = (0.9).toFixed() !== '1',
+        math = Math;
+
+    Ext.apply(this, {
+        
+        constrain: function(number, min, max) {
+            var x = parseFloat(number);
+
+            
+            
+
+            
+            
+            
+            
+            
+            return (x < min) ? min : ((x > max) ? max : x);
+        },
+
+        
+        snap : function(value, increment, minValue, maxValue) {
+            var m;
+
+            
+            
+            if (value === undefined || value < minValue) {
+                return minValue || 0;
+            }
+
+            if (increment) {
+                m = value % increment;
+                if (m !== 0) {
+                    value -= m;
+                    if (m * 2 >= increment) {
+                        value += increment;
+                    } else if (m * 2 < -increment) {
+                        value -= increment;
+                    }
+                }
+            }
+            return me.constrain(value, minValue,  maxValue);
+        },
+
+        
+        snapInRange : function(value, increment, minValue, maxValue) {
+            var tween;
+
+            
+            minValue = (minValue || 0);
+
+            
+            if (value === undefined || value < minValue) {
+                return minValue;
+            }
+
+            
+            if (increment && (tween = ((value - minValue) % increment))) {
+                value -= tween;
+                tween *= 2;
+                if (tween >= increment) {
+                    value += increment;
+                }
+            }
+
+            
+            if (maxValue !== undefined) {
+                if (value > (maxValue = me.snapInRange(maxValue, increment, minValue))) {
+                    value = maxValue;
+                }
+            }
+
+            return value;
+        },
+
+        
+        toFixed: isToFixedBroken ? function(value, precision) {
+            precision = precision || 0;
+            var pow = math.pow(10, precision);
+            return (math.round(value * pow) / pow).toFixed(precision);
+        } : function(value, precision) {
+            return value.toFixed(precision);
+        },
+
+        
+        from: function(value, defaultValue) {
+            if (isFinite(value)) {
+                value = parseFloat(value);
+            }
+
+            return !isNaN(value) ? value : defaultValue;
+        },
+
+        
+        randomInt: function (from, to) {
+           return math.floor(math.random() * (to - from + 1) + from);
+        }
+    });
+
+    
+    Ext.num = function() {
+        return me.from.apply(this, arguments);
+    };
+};
+
+//@tag foundation,core
+
+//@require Number.js
+
+
+
+(function() {
+
+    var arrayPrototype = Array.prototype,
+        slice = arrayPrototype.slice,
+        supportsSplice = (function () {
+            var array = [],
+                lengthBefore,
+                j = 20;
+
+            if (!array.splice) {
+                return false;
+            }
+
+            
+            
+
+            while (j--) {
+                array.push("A");
+            }
+
+            array.splice(15, 0, "F", "F", "F", "F", "F","F","F","F","F","F","F","F","F","F","F","F","F","F","F","F","F");
+
+            lengthBefore = array.length; 
+            array.splice(13, 0, "XXX"); 
+
+            if (lengthBefore+1 != array.length) {
+                return false;
+            }
+            
+
+            return true;
+        }()),
+        supportsForEach = 'forEach' in arrayPrototype,
+        supportsMap = 'map' in arrayPrototype,
+        supportsIndexOf = 'indexOf' in arrayPrototype,
+        supportsEvery = 'every' in arrayPrototype,
+        supportsSome = 'some' in arrayPrototype,
+        supportsFilter = 'filter' in arrayPrototype,
+        supportsSort = (function() {
+            var a = [1,2,3,4,5].sort(function(){ return 0; });
+            return a[0] === 1 && a[1] === 2 && a[2] === 3 && a[3] === 4 && a[4] === 5;
+        }()),
+        supportsSliceOnNodeList = true,
+        ExtArray,
+        erase,
+        replace,
+        splice;
+
+    try {
+        
+        if (typeof document !== 'undefined') {
+            slice.call(document.getElementsByTagName('body'));
+        }
+    } catch (e) {
+        supportsSliceOnNodeList = false;
+    }
+
+    function fixArrayIndex (array, index) {
+        return (index < 0) ? Math.max(0, array.length + index)
+                           : Math.min(array.length, index);
+    }
+
+    
+    function replaceSim (array, index, removeCount, insert) {
+        var add = insert ? insert.length : 0,
+            length = array.length,
+            pos = fixArrayIndex(array, index),
+            remove,
+            tailOldPos,
+            tailNewPos,
+            tailCount,
+            lengthAfterRemove,
+            i;
+
+        
+        if (pos === length) {
+            if (add) {
+                array.push.apply(array, insert);
+            }
+        } else {
+            remove = Math.min(removeCount, length - pos);
+            tailOldPos = pos + remove;
+            tailNewPos = tailOldPos + add - remove;
+            tailCount = length - tailOldPos;
+            lengthAfterRemove = length - remove;
+
+            if (tailNewPos < tailOldPos) { 
+                for (i = 0; i < tailCount; ++i) {
+                    array[tailNewPos+i] = array[tailOldPos+i];
+                }
+            } else if (tailNewPos > tailOldPos) { 
+                for (i = tailCount; i--; ) {
+                    array[tailNewPos+i] = array[tailOldPos+i];
+                }
+            } 
+
+            if (add && pos === lengthAfterRemove) {
+                array.length = lengthAfterRemove; 
+                array.push.apply(array, insert);
+            } else {
+                array.length = lengthAfterRemove + add; 
+                for (i = 0; i < add; ++i) {
+                    array[pos+i] = insert[i];
+                }
+            }
+        }
+
+        return array;
+    }
+
+    function replaceNative (array, index, removeCount, insert) {
+        if (insert && insert.length) {
+            if (index < array.length) {
+                array.splice.apply(array, [index, removeCount].concat(insert));
+            } else {
+                array.push.apply(array, insert);
+            }
+        } else {
+            array.splice(index, removeCount);
+        }
+        return array;
+    }
+
+    function eraseSim (array, index, removeCount) {
+        return replaceSim(array, index, removeCount);
+    }
+
+    function eraseNative (array, index, removeCount) {
+        array.splice(index, removeCount);
+        return array;
+    }
+
+    function spliceSim (array, index, removeCount) {
+        var pos = fixArrayIndex(array, index),
+            removed = array.slice(index, fixArrayIndex(array, pos+removeCount));
+
+        if (arguments.length < 4) {
+            replaceSim(array, pos, removeCount);
+        } else {
+            replaceSim(array, pos, removeCount, slice.call(arguments, 3));
+        }
+
+        return removed;
+    }
+
+    function spliceNative (array) {
+        return array.splice.apply(array, slice.call(arguments, 1));
+    }
+
+    erase = supportsSplice ? eraseNative : eraseSim;
+    replace = supportsSplice ? replaceNative : replaceSim;
+    splice = supportsSplice ? spliceNative : spliceSim;
+
+    
+
+    ExtArray = Ext.Array = {
+        
+        each: function(array, fn, scope, reverse) {
+            array = ExtArray.from(array);
+
+            var i,
+                ln = array.length;
+
+            if (reverse !== true) {
+                for (i = 0; i < ln; i++) {
+                    if (fn.call(scope || array[i], array[i], i, array) === false) {
+                        return i;
+                    }
+                }
+            }
+            else {
+                for (i = ln - 1; i > -1; i--) {
+                    if (fn.call(scope || array[i], array[i], i, array) === false) {
+                        return i;
+                    }
+                }
+            }
+
+            return true;
+        },
+
+        
+        forEach: supportsForEach ? function(array, fn, scope) {
+            return array.forEach(fn, scope);
+        } : function(array, fn, scope) {
+            var i = 0,
+                ln = array.length;
+
+            for (; i < ln; i++) {
+                fn.call(scope, array[i], i, array);
+            }
+        },
+
+        
+        indexOf: supportsIndexOf ? function(array, item, from) {
+            return array.indexOf(item, from);
+         } : function(array, item, from) {
+            var i, length = array.length;
+
+            for (i = (from < 0) ? Math.max(0, length + from) : from || 0; i < length; i++) {
+                if (array[i] === item) {
+                    return i;
+                }
+            }
+
+            return -1;
+        },
+
+        
+        contains: supportsIndexOf ? function(array, item) {
+            return array.indexOf(item) !== -1;
+        } : function(array, item) {
+            var i, ln;
+
+            for (i = 0, ln = array.length; i < ln; i++) {
+                if (array[i] === item) {
+                    return true;
+                }
+            }
+
+            return false;
+        },
+
+        
+        toArray: function(iterable, start, end){
+            if (!iterable || !iterable.length) {
+                return [];
+            }
+
+            if (typeof iterable === 'string') {
+                iterable = iterable.split('');
+            }
+
+            if (supportsSliceOnNodeList) {
+                return slice.call(iterable, start || 0, end || iterable.length);
+            }
+
+            var array = [],
+                i;
+
+            start = start || 0;
+            end = end ? ((end < 0) ? iterable.length + end : end) : iterable.length;
+
+            for (i = start; i < end; i++) {
+                array.push(iterable[i]);
+            }
+
+            return array;
+        },
+
+        
+        pluck: function(array, propertyName) {
+            var ret = [],
+                i, ln, item;
+
+            for (i = 0, ln = array.length; i < ln; i++) {
+                item = array[i];
+
+                ret.push(item[propertyName]);
+            }
+
+            return ret;
+        },
+
+        
+        map: supportsMap ? function(array, fn, scope) {
+            return array.map(fn, scope);
+        } : function(array, fn, scope) {
+            var results = [],
+                i = 0,
+                len = array.length;
+
+            for (; i < len; i++) {
+                results[i] = fn.call(scope, array[i], i, array);
+            }
+
+            return results;
+        },
+
+        
+        every: supportsEvery ? function(array, fn, scope) {
+            return array.every(fn, scope);
+        } : function(array, fn, scope) {
+            var i = 0,
+                ln = array.length;
+
+            for (; i < ln; ++i) {
+                if (!fn.call(scope, array[i], i, array)) {
+                    return false;
+                }
+            }
+
+            return true;
+        },
+
+        
+        some: supportsSome ? function(array, fn, scope) {
+            return array.some(fn, scope);
+        } : function(array, fn, scope) {
+            var i = 0,
+                ln = array.length;
+
+            for (; i < ln; ++i) {
+                if (fn.call(scope, array[i], i, array)) {
+                    return true;
+                }
+            }
+
+            return false;
+        },
+
+        
+        clean: function(array) {
+            var results = [],
+                i = 0,
+                ln = array.length,
+                item;
+
+            for (; i < ln; i++) {
+                item = array[i];
+
+                if (!Ext.isEmpty(item)) {
+                    results.push(item);
+                }
+            }
+
+            return results;
+        },
+
+        
+        unique: function(array) {
+            var clone = [],
+                i = 0,
+                ln = array.length,
+                item;
+
+            for (; i < ln; i++) {
+                item = array[i];
+
+                if (ExtArray.indexOf(clone, item) === -1) {
+                    clone.push(item);
+                }
+            }
+
+            return clone;
+        },
+
+        
+        filter: supportsFilter ? function(array, fn, scope) {
+            return array.filter(fn, scope);
+        } : function(array, fn, scope) {
+            var results = [],
+                i = 0,
+                ln = array.length;
+
+            for (; i < ln; i++) {
+                if (fn.call(scope, array[i], i, array)) {
+                    results.push(array[i]);
+                }
+            }
+
+            return results;
+        },
+
+        
+        from: function(value, newReference) {
+            if (value === undefined || value === null) {
+                return [];
+            }
+
+            if (Ext.isArray(value)) {
+                return (newReference) ? slice.call(value) : value;
+            }
+
+            var type = typeof value;
+            
+            
+            if (value && value.length !== undefined && type !== 'string' && (type !== 'function' || !value.apply)) {
+                return ExtArray.toArray(value);
+            }
+
+            return [value];
+        },
+
+        
+        remove: function(array, item) {
+            var index = ExtArray.indexOf(array, item);
+
+            if (index !== -1) {
+                erase(array, index, 1);
+            }
+
+            return array;
+        },
+
+        
+        include: function(array, item) {
+            if (!ExtArray.contains(array, item)) {
+                array.push(item);
+            }
+        },
+
+        
+        clone: function(array) {
+            return slice.call(array);
+        },
+
+        
+        merge: function() {
+            var args = slice.call(arguments),
+                array = [],
+                i, ln;
+
+            for (i = 0, ln = args.length; i < ln; i++) {
+                array = array.concat(args[i]);
+            }
+
+            return ExtArray.unique(array);
+        },
+
+        
+        intersect: function() {
+            var intersection = [],
+                arrays = slice.call(arguments),
+                arraysLength,
+                array,
+                arrayLength,
+                minArray,
+                minArrayIndex,
+                minArrayCandidate,
+                minArrayLength,
+                element,
+                elementCandidate,
+                elementCount,
+                i, j, k;
+
+            if (!arrays.length) {
+                return intersection;
+            }
+
+            
+            arraysLength = arrays.length;
+            for (i = minArrayIndex = 0; i < arraysLength; i++) {
+                minArrayCandidate = arrays[i];
+                if (!minArray || minArrayCandidate.length < minArray.length) {
+                    minArray = minArrayCandidate;
+                    minArrayIndex = i;
+                }
+            }
+
+            minArray = ExtArray.unique(minArray);
+            erase(arrays, minArrayIndex, 1);
+
+            
+            
+            
+            minArrayLength = minArray.length;
+            arraysLength = arrays.length;
+            for (i = 0; i < minArrayLength; i++) {
+                element = minArray[i];
+                elementCount = 0;
+
+                for (j = 0; j < arraysLength; j++) {
+                    array = arrays[j];
+                    arrayLength = array.length;
+                    for (k = 0; k < arrayLength; k++) {
+                        elementCandidate = array[k];
+                        if (element === elementCandidate) {
+                            elementCount++;
+                            break;
+                        }
+                    }
+                }
+
+                if (elementCount === arraysLength) {
+                    intersection.push(element);
+                }
+            }
+
+            return intersection;
+        },
+
+        
+        difference: function(arrayA, arrayB) {
+            var clone = slice.call(arrayA),
+                ln = clone.length,
+                i, j, lnB;
+
+            for (i = 0,lnB = arrayB.length; i < lnB; i++) {
+                for (j = 0; j < ln; j++) {
+                    if (clone[j] === arrayB[i]) {
+                        erase(clone, j, 1);
+                        j--;
+                        ln--;
+                    }
+                }
+            }
+
+            return clone;
+        },
+
+        
+        
+        slice: ([1,2].slice(1, undefined).length ?
+            function (array, begin, end) {
+                return slice.call(array, begin, end);
+            } :
+            
+            function (array, begin, end) {
+                
+                
+                if (typeof begin === 'undefined') {
+                    return slice.call(array);
+                }
+                if (typeof end === 'undefined') {
+                    return slice.call(array, begin);
+                }
+                return slice.call(array, begin, end);
+            }
+        ),
+
+        
+        sort: supportsSort ? function(array, sortFn) {
+            if (sortFn) {
+                return array.sort(sortFn);
+            } else {
+                return array.sort();
+            }
+         } : function(array, sortFn) {
+            var length = array.length,
+                i = 0,
+                comparison,
+                j, min, tmp;
+
+            for (; i < length; i++) {
+                min = i;
+                for (j = i + 1; j < length; j++) {
+                    if (sortFn) {
+                        comparison = sortFn(array[j], array[min]);
+                        if (comparison < 0) {
+                            min = j;
+                        }
+                    } else if (array[j] < array[min]) {
+                        min = j;
+                    }
+                }
+                if (min !== i) {
+                    tmp = array[i];
+                    array[i] = array[min];
+                    array[min] = tmp;
+                }
+            }
+
+            return array;
+        },
+
+        
+        flatten: function(array) {
+            var worker = [];
+
+            function rFlatten(a) {
+                var i, ln, v;
+
+                for (i = 0, ln = a.length; i < ln; i++) {
+                    v = a[i];
+
+                    if (Ext.isArray(v)) {
+                        rFlatten(v);
+                    } else {
+                        worker.push(v);
+                    }
+                }
+
+                return worker;
+            }
+
+            return rFlatten(array);
+        },
+
+        
+        min: function(array, comparisonFn) {
+            var min = array[0],
+                i, ln, item;
+
+            for (i = 0, ln = array.length; i < ln; i++) {
+                item = array[i];
+
+                if (comparisonFn) {
+                    if (comparisonFn(min, item) === 1) {
+                        min = item;
+                    }
+                }
+                else {
+                    if (item < min) {
+                        min = item;
+                    }
+                }
+            }
+
+            return min;
+        },
+
+        
+        max: function(array, comparisonFn) {
+            var max = array[0],
+                i, ln, item;
+
+            for (i = 0, ln = array.length; i < ln; i++) {
+                item = array[i];
+
+                if (comparisonFn) {
+                    if (comparisonFn(max, item) === -1) {
+                        max = item;
+                    }
+                }
+                else {
+                    if (item > max) {
+                        max = item;
+                    }
+                }
+            }
+
+            return max;
+        },
+
+        
+        mean: function(array) {
+            return array.length > 0 ? ExtArray.sum(array) / array.length : undefined;
+        },
+
+        
+        sum: function(array) {
+            var sum = 0,
+                i, ln, item;
+
+            for (i = 0,ln = array.length; i < ln; i++) {
+                item = array[i];
+
+                sum += item;
+            }
+
+            return sum;
+        },
+
+        
+        toMap: function(array, getKey, scope) {
+            var map = {},
+                i = array.length;
+
+            if (!getKey) {
+                while (i--) {
+                    map[array[i]] = i+1;
+                }
+            } else if (typeof getKey == 'string') {
+                while (i--) {
+                    map[array[i][getKey]] = i+1;
+                }
+            } else {
+                while (i--) {
+                    map[getKey.call(scope, array[i])] = i+1;
+                }
+            }
+
+            return map;
+        },
+
+
+        
+        erase: erase,
+
+        
+        insert: function (array, index, items) {
+            return replace(array, index, 0, items);
+        },
+
+        
+        replace: replace,
+
+        
+        splice: splice,
+
+        
+        push: function(array) {
+            var len = arguments.length,
+                i = 1,
+                newItem;
+
+            if (array === undefined) {
+                array = [];
+            } else if (!Ext.isArray(array)) {
+                array = [array];
+            }
+            for (; i < len; i++) {
+                newItem = arguments[i];
+                Array.prototype.push[Ext.isArray(newItem) ? 'apply' : 'call'](array, newItem);
+            }
+            return array;
+        }
+    };
+
+    
+    Ext.each = ExtArray.each;
+
+    
+    ExtArray.union = ExtArray.merge;
+
+    
+    Ext.min = ExtArray.min;
+
+    
+    Ext.max = ExtArray.max;
+
+    
+    Ext.sum = ExtArray.sum;
+
+    
+    Ext.mean = ExtArray.mean;
+
+    
+    Ext.flatten = ExtArray.flatten;
+
+    
+    Ext.clean = ExtArray.clean;
+
+    
+    Ext.unique = ExtArray.unique;
+
+    
+    Ext.pluck = ExtArray.pluck;
+
+    
+    Ext.toArray = function() {
+        return ExtArray.toArray.apply(ExtArray, arguments);
+    };
+}());
+
+//@tag foundation,core
+
+//@require Array.js
+
+
+
+Ext.Function = {
+
+    
+    flexSetter: function(fn) {
+        return function(a, b) {
+            var k, i;
+
+            if (a === null) {
+                return this;
+            }
+
+            if (typeof a !== 'string') {
+                for (k in a) {
+                    if (a.hasOwnProperty(k)) {
+                        fn.call(this, k, a[k]);
+                    }
+                }
+
+                if (Ext.enumerables) {
+                    for (i = Ext.enumerables.length; i--;) {
+                        k = Ext.enumerables[i];
+                        if (a.hasOwnProperty(k)) {
+                            fn.call(this, k, a[k]);
+                        }
+                    }
+                }
+            } else {
+                fn.call(this, a, b);
+            }
+
+            return this;
+        };
+    },
+
+    
+    bind: function(fn, scope, args, appendArgs) {
+        if (arguments.length === 2) {
+            return function() {
+                return fn.apply(scope, arguments);
+            };
+        }
+
+        var method = fn,
+            slice = Array.prototype.slice;
+
+        return function() {
+            var callArgs = args || arguments;
+
+            if (appendArgs === true) {
+                callArgs = slice.call(arguments, 0);
+                callArgs = callArgs.concat(args);
+            }
+            else if (typeof appendArgs == 'number') {
+                callArgs = slice.call(arguments, 0); 
+                Ext.Array.insert(callArgs, appendArgs, args);
+            }
+
+            return method.apply(scope || Ext.global, callArgs);
+        };
+    },
+
+    
+    pass: function(fn, args, scope) {
+        if (!Ext.isArray(args)) {
+            if (Ext.isIterable(args)) {
+                args = Ext.Array.clone(args);
+            } else {
+                args = args !== undefined ? [args] : [];
+            }
+        }
+
+        return function() {
+            var fnArgs = [].concat(args);
+            fnArgs.push.apply(fnArgs, arguments);
+            return fn.apply(scope || this, fnArgs);
+        };
+    },
+
+    
+    alias: function(object, methodName) {
+        return function() {
+            return object[methodName].apply(object, arguments);
+        };
+    },
+
+    
+    clone: function(method) {
+        return function() {
+            return method.apply(this, arguments);
+        };
+    },
+
+    
+    createInterceptor: function(origFn, newFn, scope, returnValue) {
+        var method = origFn;
+        if (!Ext.isFunction(newFn)) {
+            return origFn;
+        }
+        else {
+            return function() {
+                var me = this,
+                    args = arguments;
+                newFn.target = me;
+                newFn.method = origFn;
+                return (newFn.apply(scope || me || Ext.global, args) !== false) ? origFn.apply(me || Ext.global, args) : returnValue || null;
+            };
+        }
+    },
+
+    
+    createDelayed: function(fn, delay, scope, args, appendArgs) {
+        if (scope || args) {
+            fn = Ext.Function.bind(fn, scope, args, appendArgs);
+        }
+
+        return function() {
+            var me = this,
+                args = Array.prototype.slice.call(arguments);
+
+            setTimeout(function() {
+                fn.apply(me, args);
+            }, delay);
+        };
+    },
+
+    
+    defer: function(fn, millis, scope, args, appendArgs) {
+        fn = Ext.Function.bind(fn, scope, args, appendArgs);
+        if (millis > 0) {
+            return setTimeout(Ext.supports.TimeoutActualLateness ? function () {
+                fn();
+            } : fn, millis);
+        }
+        fn();
+        return 0;
+    },
+
+    
+    createSequence: function(originalFn, newFn, scope) {
+        if (!newFn) {
+            return originalFn;
+        }
+        else {
+            return function() {
+                var result = originalFn.apply(this, arguments);
+                newFn.apply(scope || this, arguments);
+                return result;
+            };
+        }
+    },
+
+    
+    createBuffered: function(fn, buffer, scope, args) {
+        var timerId;
+
+        return function() {
+            var callArgs = args || Array.prototype.slice.call(arguments, 0),
+                me = scope || this;
+
+            if (timerId) {
+                clearTimeout(timerId);
+            }
+
+            timerId = setTimeout(function(){
+                fn.apply(me, callArgs);
+            }, buffer);
+        };
+    },
+
+    
+    createThrottled: function(fn, interval, scope) {
+        var lastCallTime, elapsed, lastArgs, timer, execute = function() {
+            fn.apply(scope || this, lastArgs);
+            lastCallTime = new Date().getTime();
+        };
+
+        return function() {
+            elapsed = new Date().getTime() - lastCallTime;
+            lastArgs = arguments;
+
+            clearTimeout(timer);
+            if (!lastCallTime || (elapsed >= interval)) {
+                execute();
+            } else {
+                timer = setTimeout(execute, interval - elapsed);
+            }
+        };
+    },
+
+
+    
+    interceptBefore: function(object, methodName, fn, scope) {
+        var method = object[methodName] || Ext.emptyFn;
+
+        return (object[methodName] = function() {
+            var ret = fn.apply(scope || this, arguments);
+            method.apply(this, arguments);
+
+            return ret;
+        });
+    },
+
+    
+    interceptAfter: function(object, methodName, fn, scope) {
+        var method = object[methodName] || Ext.emptyFn;
+
+        return (object[methodName] = function() {
+            method.apply(this, arguments);
+            return fn.apply(scope || this, arguments);
+        });
+    }
+};
+
+
+Ext.defer = Ext.Function.alias(Ext.Function, 'defer');
+
+
+Ext.pass = Ext.Function.alias(Ext.Function, 'pass');
+
+
+Ext.bind = Ext.Function.alias(Ext.Function, 'bind');
+
+//@tag foundation,core
+
+//@require Function.js
+
+
+
+
+(function() {
+
+
+var TemplateClass = function(){},
+    ExtObject = Ext.Object = {
+
+    
+    chain: function (object) {
+        TemplateClass.prototype = object;
+        var result = new TemplateClass();
+        TemplateClass.prototype = null;
+        return result;
+    },
+
+    
+    toQueryObjects: function(name, value, recursive) {
+        var self = ExtObject.toQueryObjects,
+            objects = [],
+            i, ln;
+
+        if (Ext.isArray(value)) {
+            for (i = 0, ln = value.length; i < ln; i++) {
+                if (recursive) {
+                    objects = objects.concat(self(name + '[' + i + ']', value[i], true));
+                }
+                else {
+                    objects.push({
+                        name: name,
+                        value: value[i]
+                    });
+                }
+            }
+        }
+        else if (Ext.isObject(value)) {
+            for (i in value) {
+                if (value.hasOwnProperty(i)) {
+                    if (recursive) {
+                        objects = objects.concat(self(name + '[' + i + ']', value[i], true));
+                    }
+                    else {
+                        objects.push({
+                            name: name,
+                            value: value[i]
+                        });
+                    }
+                }
+            }
+        }
+        else {
+            objects.push({
+                name: name,
+                value: value
+            });
+        }
+
+        return objects;
+    },
+
+    
+    toQueryString: function(object, recursive) {
+        var paramObjects = [],
+            params = [],
+            i, j, ln, paramObject, value;
+
+        for (i in object) {
+            if (object.hasOwnProperty(i)) {
+                paramObjects = paramObjects.concat(ExtObject.toQueryObjects(i, object[i], recursive));
+            }
+        }
+
+        for (j = 0, ln = paramObjects.length; j < ln; j++) {
+            paramObject = paramObjects[j];
+            value = paramObject.value;
+
+            if (Ext.isEmpty(value)) {
+                value = '';
+            }
+            else if (Ext.isDate(value)) {
+                value = Ext.Date.toString(value);
+            }
+
+            params.push(encodeURIComponent(paramObject.name) + '=' + encodeURIComponent(String(value)));
+        }
+
+        return params.join('&');
+    },
+
+    
+    fromQueryString: function(queryString, recursive) {
+        var parts = queryString.replace(/^\?/, '').split('&'),
+            object = {},
+            temp, components, name, value, i, ln,
+            part, j, subLn, matchedKeys, matchedName,
+            keys, key, nextKey;
+
+        for (i = 0, ln = parts.length; i < ln; i++) {
+            part = parts[i];
+
+            if (part.length > 0) {
+                components = part.split('=');
+                name = decodeURIComponent(components[0]);
+                value = (components[1] !== undefined) ? decodeURIComponent(components[1]) : '';
+
+                if (!recursive) {
+                    if (object.hasOwnProperty(name)) {
+                        if (!Ext.isArray(object[name])) {
+                            object[name] = [object[name]];
+                        }
+
+                        object[name].push(value);
+                    }
+                    else {
+                        object[name] = value;
+                    }
+                }
+                else {
+                    matchedKeys = name.match(/(\[):?([^\]]*)\]/g);
+                    matchedName = name.match(/^([^\[]+)/);
+
+
+                    name = matchedName[0];
+                    keys = [];
+
+                    if (matchedKeys === null) {
+                        object[name] = value;
+                        continue;
+                    }
+
+                    for (j = 0, subLn = matchedKeys.length; j < subLn; j++) {
+                        key = matchedKeys[j];
+                        key = (key.length === 2) ? '' : key.substring(1, key.length - 1);
+                        keys.push(key);
+                    }
+
+                    keys.unshift(name);
+
+                    temp = object;
+
+                    for (j = 0, subLn = keys.length; j < subLn; j++) {
+                        key = keys[j];
+
+                        if (j === subLn - 1) {
+                            if (Ext.isArray(temp) && key === '') {
+                                temp.push(value);
+                            }
+                            else {
+                                temp[key] = value;
+                            }
+                        }
+                        else {
+                            if (temp[key] === undefined || typeof temp[key] === 'string') {
+                                nextKey = keys[j+1];
+
+                                temp[key] = (Ext.isNumeric(nextKey) || nextKey === '') ? [] : {};
+                            }
+
+                            temp = temp[key];
+                        }
+                    }
+                }
+            }
+        }
+
+        return object;
+    },
+
+    
+    each: function(object, fn, scope) {
+        for (var property in object) {
+            if (object.hasOwnProperty(property)) {
+                if (fn.call(scope || object, property, object[property], object) === false) {
+                    return;
+                }
+            }
+        }
+    },
+
+    
+    merge: function(destination) {
+        var i = 1,
+            ln = arguments.length,
+            mergeFn = ExtObject.merge,
+            cloneFn = Ext.clone,
+            object, key, value, sourceKey;
+
+        for (; i < ln; i++) {
+            object = arguments[i];
+
+            for (key in object) {
+                value = object[key];
+                if (value && value.constructor === Object) {
+                    sourceKey = destination[key];
+                    if (sourceKey && sourceKey.constructor === Object) {
+                        mergeFn(sourceKey, value);
+                    }
+                    else {
+                        destination[key] = cloneFn(value);
+                    }
+                }
+                else {
+                    destination[key] = value;
+                }
+            }
+        }
+
+        return destination;
+    },
+
+    
+    mergeIf: function(destination) {
+        var i = 1,
+            ln = arguments.length,
+            cloneFn = Ext.clone,
+            object, key, value;
+
+        for (; i < ln; i++) {
+            object = arguments[i];
+
+            for (key in object) {
+                if (!(key in destination)) {
+                    value = object[key];
+
+                    if (value && value.constructor === Object) {
+                        destination[key] = cloneFn(value);
+                    }
+                    else {
+                        destination[key] = value;
+                    }
+                }
+            }
+        }
+
+        return destination;
+    },
+
+    
+    getKey: function(object, value) {
+        for (var property in object) {
+            if (object.hasOwnProperty(property) && object[property] === value) {
+                return property;
+            }
+        }
+
+        return null;
+    },
+
+    
+    getValues: function(object) {
+        var values = [],
+            property;
+
+        for (property in object) {
+            if (object.hasOwnProperty(property)) {
+                values.push(object[property]);
+            }
+        }
+
+        return values;
+    },
+
+    
+    getKeys: (typeof Object.keys == 'function')
+        ? function(object){
+            if (!object) {
+                return [];
+            }
+            return Object.keys(object);
+        }
+        : function(object) {
+            var keys = [],
+                property;
+
+            for (property in object) {
+                if (object.hasOwnProperty(property)) {
+                    keys.push(property);
+                }
+            }
+
+            return keys;
+        },
+
+    
+    getSize: function(object) {
+        var size = 0,
+            property;
+
+        for (property in object) {
+            if (object.hasOwnProperty(property)) {
+                size++;
+            }
+        }
+
+        return size;
+    },
+
+    
+    classify: function(object) {
+        var prototype = object,
+            objectProperties = [],
+            propertyClassesMap = {},
+            objectClass = function() {
+                var i = 0,
+                    ln = objectProperties.length,
+                    property;
+
+                for (; i < ln; i++) {
+                    property = objectProperties[i];
+                    this[property] = new propertyClassesMap[property]();
+                }
+            },
+            key, value;
+
+        for (key in object) {
+            if (object.hasOwnProperty(key)) {
+                value = object[key];
+
+                if (value && value.constructor === Object) {
+                    objectProperties.push(key);
+                    propertyClassesMap[key] = ExtObject.classify(value);
+                }
+            }
+        }
+
+        objectClass.prototype = prototype;
+
+        return objectClass;
+    }
+};
+
+
+Ext.merge = Ext.Object.merge;
+
+
+Ext.mergeIf = Ext.Object.mergeIf;
+
+
+Ext.urlEncode = function() {
+    var args = Ext.Array.from(arguments),
+        prefix = '';
+
+    
+    if ((typeof args[1] === 'string')) {
+        prefix = args[1] + '&';
+        args[1] = false;
+    }
+
+    return prefix + ExtObject.toQueryString.apply(ExtObject, args);
+};
+
+
+Ext.urlDecode = function() {
+    return ExtObject.fromQueryString.apply(ExtObject, arguments);
+};
+
+}());
+
+//@tag foundation,core
+
+//@require Object.js
+
+//@define Ext.Date
+
+
+
+
+
+
+(function() {
+
+
+
+
+function xf(format) {
+    var args = Array.prototype.slice.call(arguments, 1);
+    return format.replace(/\{(\d+)\}/g, function(m, i) {
+        return args[i];
+    });
+}
+
+Ext.Date = {
+    
+    now: Date.now || function() {
+        return +new Date();
+    },
+
+    
+    toString: function(date) {
+        var pad = Ext.String.leftPad;
+
+        return date.getFullYear() + "-"
+            + pad(date.getMonth() + 1, 2, '0') + "-"
+            + pad(date.getDate(), 2, '0') + "T"
+            + pad(date.getHours(), 2, '0') + ":"
+            + pad(date.getMinutes(), 2, '0') + ":"
+            + pad(date.getSeconds(), 2, '0');
+    },
+
+    
+    getElapsed: function(dateA, dateB) {
+        return Math.abs(dateA - (dateB || new Date()));
+    },
+
+    
+    useStrict: false,
+
+    
+    formatCodeToRegex: function(character, currentGroup) {
+        
+        var p = utilDate.parseCodes[character];
+
+        if (p) {
+          p = typeof p == 'function'? p() : p;
+          utilDate.parseCodes[character] = p; 
+        }
+
+        return p ? Ext.applyIf({
+          c: p.c ? xf(p.c, currentGroup || "{0}") : p.c
+        }, p) : {
+            g: 0,
+            c: null,
+            s: Ext.String.escapeRegex(character) 
+        };
+    },
+
+    
+    parseFunctions: {
+        "MS": function(input, strict) {
+            
+            
+            var re = new RegExp('\\/Date\\(([-+])?(\\d+)(?:[+-]\\d{4})?\\)\\/'),
+                r = (input || '').match(re);
+            return r? new Date(((r[1] || '') + r[2]) * 1) : null;
+        }
+    },
+    parseRegexes: [],
+
+    
+    formatFunctions: {
+        "MS": function() {
+            
+            return '\\/Date(' + this.getTime() + ')\\/';
+        }
+    },
+
+    y2kYear : 50,
+
+    
+    MILLI : "ms",
+
+    
+    SECOND : "s",
+
+    
+    MINUTE : "mi",
+
+    
+    HOUR : "h",
+
+    
+    DAY : "d",
+
+    
+    MONTH : "mo",
+
+    
+    YEAR : "y",
+
+    
+    defaults: {},
+
+    
+    
+    dayNames : [
+        "Sunday",
+        "Monday",
+        "Tuesday",
+        "Wednesday",
+        "Thursday",
+        "Friday",
+        "Saturday"
+    ],
+    
+
+    
+    
+    monthNames : [
+        "January",
+        "February",
+        "March",
+        "April",
+        "May",
+        "June",
+        "July",
+        "August",
+        "September",
+        "October",
+        "November",
+        "December"
+    ],
+    
+
+    
+    
+    monthNumbers : {
+        January: 0,
+        Jan: 0,
+        February: 1,
+        Feb: 1,
+        March: 2,
+        Mar: 2,
+        April: 3,
+        Apr: 3,
+        May: 4,
+        June: 5,
+        Jun: 5,
+        July: 6,
+        Jul: 6,
+        August: 7,
+        Aug: 7,
+        September: 8,
+        Sep: 8,
+        October: 9,
+        Oct: 9,
+        November: 10,
+        Nov: 10,
+        December: 11,
+        Dec: 11
+    },
+    
+    
+    
+    
+    defaultFormat : "m/d/Y",
+    
+    
+    
+    getShortMonthName : function(month) {
+        return Ext.Date.monthNames[month].substring(0, 3);
+    },
+    
+
+    
+    
+    getShortDayName : function(day) {
+        return Ext.Date.dayNames[day].substring(0, 3);
+    },
+    
+
+    
+    
+    getMonthNumber : function(name) {
+        
+        return Ext.Date.monthNumbers[name.substring(0, 1).toUpperCase() + name.substring(1, 3).toLowerCase()];
+    },
+    
+
+    
+    formatContainsHourInfo : (function(){
+        var stripEscapeRe = /(\\.)/g,
+            hourInfoRe = /([gGhHisucUOPZ]|MS)/;
+        return function(format){
+            return hourInfoRe.test(format.replace(stripEscapeRe, ''));
+        };
+    }()),
+
+    
+    formatContainsDateInfo : (function(){
+        var stripEscapeRe = /(\\.)/g,
+            dateInfoRe = /([djzmnYycU]|MS)/;
+
+        return function(format){
+            return dateInfoRe.test(format.replace(stripEscapeRe, ''));
+        };
+    }()),
+    
+    
+    unescapeFormat: (function() { 
+        var slashRe = /\\/gi;
+        return function(format) {
+            
+            
+            
+            return format.replace(slashRe, '');
+        }
+    }()),
+
+    
+    formatCodes : {
+        d: "Ext.String.leftPad(this.getDate(), 2, '0')",
+        D: "Ext.Date.getShortDayName(this.getDay())", 
+        j: "this.getDate()",
+        l: "Ext.Date.dayNames[this.getDay()]",
+        N: "(this.getDay() ? this.getDay() : 7)",
+        S: "Ext.Date.getSuffix(this)",
+        w: "this.getDay()",
+        z: "Ext.Date.getDayOfYear(this)",
+        W: "Ext.String.leftPad(Ext.Date.getWeekOfYear(this), 2, '0')",
+        F: "Ext.Date.monthNames[this.getMonth()]",
+        m: "Ext.String.leftPad(this.getMonth() + 1, 2, '0')",
+        M: "Ext.Date.getShortMonthName(this.getMonth())", 
+        n: "(this.getMonth() + 1)",
+        t: "Ext.Date.getDaysInMonth(this)",
+        L: "(Ext.Date.isLeapYear(this) ? 1 : 0)",
+        o: "(this.getFullYear() + (Ext.Date.getWeekOfYear(this) == 1 && this.getMonth() > 0 ? +1 : (Ext.Date.getWeekOfYear(this) >= 52 && this.getMonth() < 11 ? -1 : 0)))",
+        Y: "Ext.String.leftPad(this.getFullYear(), 4, '0')",
+        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: "Ext.String.leftPad((this.getHours() % 12) ? this.getHours() % 12 : 12, 2, '0')",
+        H: "Ext.String.leftPad(this.getHours(), 2, '0')",
+        i: "Ext.String.leftPad(this.getMinutes(), 2, '0')",
+        s: "Ext.String.leftPad(this.getSeconds(), 2, '0')",
+        u: "Ext.String.leftPad(this.getMilliseconds(), 3, '0')",
+        O: "Ext.Date.getGMTOffset(this)",
+        P: "Ext.Date.getGMTOffset(this, true)",
+        T: "Ext.Date.getTimezone(this)",
+        Z: "(this.getTimezoneOffset() * -60)",
+
+        c: function() { 
+            var c, code, i, l, e;
+            for (c = "Y-m-dTH:i:sP", code = [], i = 0, l = c.length; i < l; ++i) {
+                e = c.charAt(i);
+                code.push(e == "T" ? "'T'" : utilDate.getFormatCode(e)); 
+            }
+            return code.join(" + ");
+        },
+        
+
+        U: "Math.round(this.getTime() / 1000)"
+    },
+
+    
+    isValid : function(y, m, d, h, i, s, ms) {
+        
+        h = h || 0;
+        i = i || 0;
+        s = s || 0;
+        ms = ms || 0;
+
+        
+        var dt = utilDate.add(new Date(y < 100 ? 100 : y, m - 1, d, h, i, s, ms), utilDate.YEAR, y < 100 ? y - 100 : 0);
+
+        return y == dt.getFullYear() &&
+            m == dt.getMonth() + 1 &&
+            d == dt.getDate() &&
+            h == dt.getHours() &&
+            i == dt.getMinutes() &&
+            s == dt.getSeconds() &&
+            ms == dt.getMilliseconds();
+    },
+
+    
+    parse : function(input, format, strict) {
+        var p = utilDate.parseFunctions;
+        if (p[format] == null) {
+            utilDate.createParser(format);
+        }
+        return p[format](input, Ext.isDefined(strict) ? strict : utilDate.useStrict);
+    },
+
+    
+    parseDate: function(input, format, strict){
+        return utilDate.parse(input, format, strict);
+    },
+
+
+    
+    getFormatCode : function(character) {
+        var f = utilDate.formatCodes[character];
+
+        if (f) {
+          f = typeof f == 'function'? f() : f;
+          utilDate.formatCodes[character] = f; 
+        }
+
+        
+        return f || ("'" + Ext.String.escape(character) + "'");
+    },
+
+    
+    createFormat : function(format) {
+        var code = [],
+            special = false,
+            ch = '',
+            i;
+
+        for (i = 0; i < format.length; ++i) {
+            ch = format.charAt(i);
+            if (!special && ch == "\\") {
+                special = true;
+            } else if (special) {
+                special = false;
+                code.push("'" + Ext.String.escape(ch) + "'");
+            } else {
+                code.push(utilDate.getFormatCode(ch));
+            }
+        }
+        utilDate.formatFunctions[format] = Ext.functionFactory("return " + code.join('+'));
+    },
+
+    
+    createParser : (function() {
+        var code = [
+            "var dt, y, m, d, h, i, s, ms, o, z, zz, u, v,",
+                "def = Ext.Date.defaults,",
+                "results = String(input).match(Ext.Date.parseRegexes[{0}]);", 
+
+            "if(results){",
+                "{1}",
+
+                "if(u != null){", 
+                    "v = new Date(u * 1000);", 
+                "}else{",
+                    
+                    
+                    
+                    "dt = Ext.Date.clearTime(new Date);",
+
+                    
+                    "y = Ext.Number.from(y, Ext.Number.from(def.y, dt.getFullYear()));",
+                    "m = Ext.Number.from(m, Ext.Number.from(def.m - 1, dt.getMonth()));",
+                    "d = Ext.Number.from(d, Ext.Number.from(def.d, dt.getDate()));",
+
+                    
+                    "h  = Ext.Number.from(h, Ext.Number.from(def.h, dt.getHours()));",
+                    "i  = Ext.Number.from(i, Ext.Number.from(def.i, dt.getMinutes()));",
+                    "s  = Ext.Number.from(s, Ext.Number.from(def.s, dt.getSeconds()));",
+                    "ms = Ext.Number.from(ms, Ext.Number.from(def.ms, dt.getMilliseconds()));",
+
+                    "if(z >= 0 && y >= 0){",
+                        
+                        
+
+                        
+                        
+                        "v = Ext.Date.add(new Date(y < 100 ? 100 : y, 0, 1, h, i, s, ms), Ext.Date.YEAR, y < 100 ? y - 100 : 0);",
+
+                        
+                        "v = !strict? v : (strict === true && (z <= 364 || (Ext.Date.isLeapYear(v) && z <= 365))? Ext.Date.add(v, Ext.Date.DAY, z) : null);",
+                    "}else if(strict === true && !Ext.Date.isValid(y, m + 1, d, h, i, s, ms)){", 
+                        "v = null;", 
+                    "}else{",
+                        
+                        
+                        "v = Ext.Date.add(new Date(y < 100 ? 100 : y, m, d, h, i, s, ms), Ext.Date.YEAR, y < 100 ? y - 100 : 0);",
+                    "}",
+                "}",
+            "}",
+
+            "if(v){",
+                
+                "if(zz != null){",
+                    
+                    "v = Ext.Date.add(v, Ext.Date.SECOND, -v.getTimezoneOffset() * 60 - zz);",
+                "}else if(o){",
+                    
+                    "v = Ext.Date.add(v, Ext.Date.MINUTE, -v.getTimezoneOffset() + (sn == '+'? -1 : 1) * (hr * 60 + mn));",
+                "}",
+            "}",
+
+            "return v;"
+        ].join('\n');
+
+        return function(format) {
+            var regexNum = utilDate.parseRegexes.length,
+                currentGroup = 1,
+                calc = [],
+                regex = [],
+                special = false,
+                ch = "",
+                i = 0,
+                len = format.length,
+                atEnd = [],
+                obj;
+
+            for (; i < len; ++i) {
+                ch = format.charAt(i);
+                if (!special && ch == "\\") {
+                    special = true;
+                } else if (special) {
+                    special = false;
+                    regex.push(Ext.String.escape(ch));
+                } else {
+                    obj = utilDate.formatCodeToRegex(ch, currentGroup);
+                    currentGroup += obj.g;
+                    regex.push(obj.s);
+                    if (obj.g && obj.c) {
+                        if (obj.calcAtEnd) {
+                            atEnd.push(obj.c);
+                        } else {
+                            calc.push(obj.c);
+                        }
+                    }
+                }
+            }
+            
+            calc = calc.concat(atEnd);
+
+            utilDate.parseRegexes[regexNum] = new RegExp("^" + regex.join('') + "$", 'i');
+            utilDate.parseFunctions[format] = Ext.functionFactory("input", "strict", xf(code, regexNum, calc.join('')));
+        };
+    }()),
+
+    
+    parseCodes : {
+        
+        d: {
+            g:1,
+            c:"d = parseInt(results[{0}], 10);\n",
+            s:"(3[0-1]|[1-2][0-9]|0[1-9])" 
+        },
+        j: {
+            g:1,
+            c:"d = parseInt(results[{0}], 10);\n",
+            s:"(3[0-1]|[1-2][0-9]|[1-9])" 
+        },
+        D: function() {
+            for (var a = [], i = 0; i < 7; a.push(utilDate.getShortDayName(i)), ++i); 
+            return {
+                g:0,
+                c:null,
+                s:"(?:" + a.join("|") +")"
+            };
+        },
+        l: function() {
+            return {
+                g:0,
+                c:null,
+                s:"(?:" + utilDate.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:1,
+            c:"z = parseInt(results[{0}], 10);\n",
+            s:"(\\d{1,3})" 
+        },
+        W: {
+            g:0,
+            c:null,
+            s:"(?:\\d{2})" 
+        },
+        F: function() {
+            return {
+                g:1,
+                c:"m = parseInt(Ext.Date.getMonthNumber(results[{0}]), 10);\n", 
+                s:"(" + utilDate.monthNames.join("|") + ")"
+            };
+        },
+        M: function() {
+            for (var a = [], i = 0; i < 12; a.push(utilDate.getShortMonthName(i)), ++i); 
+            return Ext.applyIf({
+                s:"(" + a.join("|") + ")"
+            }, utilDate.formatCodeToRegex("F"));
+        },
+        m: {
+            g:1,
+            c:"m = parseInt(results[{0}], 10) - 1;\n",
+            s:"(1[0-2]|0[1-9])" 
+        },
+        n: {
+            g:1,
+            c:"m = parseInt(results[{0}], 10) - 1;\n",
+            s:"(1[0-2]|[1-9])" 
+        },
+        t: {
+            g:0,
+            c:null,
+            s:"(?:\\d{2})" 
+        },
+        L: {
+            g:0,
+            c:null,
+            s:"(?:1|0)"
+        },
+        o: function() {
+            return utilDate.formatCodeToRegex("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 > Ext.Date.y2kYear ? 1900 + ty : 2000 + ty;\n", 
+            s:"(\\d{1,2})"
+        },
+        
+        
+        a: {
+            g:1,
+            c:"if (/(am)/i.test(results[{0}])) {\n"
+                + "if (!h || h == 12) { h = 0; }\n"
+                + "} else { if (!h || h < 12) { h = (h || 0) + 12; }}",
+            s:"(am|pm|AM|PM)",
+            calcAtEnd: true
+        },
+        
+        
+        A: {
+            g:1,
+            c:"if (/(am)/i.test(results[{0}])) {\n"
+                + "if (!h || h == 12) { h = 0; }\n"
+                + "} else { if (!h || h < 12) { h = (h || 0) + 12; }}",
+            s:"(AM|PM|am|pm)",
+            calcAtEnd: true
+        },
+        
+        g: {
+            g:1,
+            c:"h = parseInt(results[{0}], 10);\n",
+            s:"(1[0-2]|[0-9])" 
+        },
+        G: {
+            g:1,
+            c:"h = parseInt(results[{0}], 10);\n",
+            s:"(2[0-3]|1[0-9]|[0-9])" 
+        },
+        h: {
+            g:1,
+            c:"h = parseInt(results[{0}], 10);\n",
+            s:"(1[0-2]|0[1-9])" 
+        },
+        H: {
+            g:1,
+            c:"h = parseInt(results[{0}], 10);\n",
+            s:"(2[0-3]|[0-1][0-9])" 
+        },
+        i: {
+            g:1,
+            c:"i = parseInt(results[{0}], 10);\n",
+            s:"([0-5][0-9])" 
+        },
+        s: {
+            g:1,
+            c:"s = parseInt(results[{0}], 10);\n",
+            s:"([0-5][0-9])" 
+        },
+        u: {
+            g:1,
+            c:"ms = results[{0}]; ms = parseInt(ms, 10)/Math.pow(10, ms.length - 3);\n",
+            s:"(\\d+)" 
+        },
+        O: {
+            g:1,
+            c:[
+                "o = results[{0}];",
+                "var sn = o.substring(0,1),", 
+                    "hr = o.substring(1,3)*1 + Math.floor(o.substring(3,5) / 60),", 
+                    "mn = o.substring(3,5) % 60;", 
+                "o = ((-12 <= (hr*60 + mn)/60) && ((hr*60 + mn)/60 <= 14))? (sn + Ext.String.leftPad(hr, 2, '0') + Ext.String.leftPad(mn, 2, '0')) : null;\n" 
+            ].join("\n"),
+            s: "([+-]\\d{4})" 
+        },
+        P: {
+            g:1,
+            c:[
+                "o = results[{0}];",
+                "var sn = o.substring(0,1),", 
+                    "hr = o.substring(1,3)*1 + Math.floor(o.substring(4,6) / 60),", 
+                    "mn = o.substring(4,6) % 60;", 
+                "o = ((-12 <= (hr*60 + mn)/60) && ((hr*60 + mn)/60 <= 14))? (sn + Ext.String.leftPad(hr, 2, '0') + Ext.String.leftPad(mn, 2, '0')) : null;\n" 
+            ].join("\n"),
+            s: "([+-]\\d{2}:\\d{2})" 
+        },
+        T: {
+            g:0,
+            c:null,
+            s:"[A-Z]{1,4}" 
+        },
+        Z: {
+            g:1,
+            c:"zz = results[{0}] * 1;\n" 
+                  + "zz = (-43200 <= zz && zz <= 50400)? zz : null;\n",
+            s:"([+-]?\\d{1,5})" 
+        },
+        c: function() {
+            var calc = [],
+                arr = [
+                    utilDate.formatCodeToRegex("Y", 1), 
+                    utilDate.formatCodeToRegex("m", 2), 
+                    utilDate.formatCodeToRegex("d", 3), 
+                    utilDate.formatCodeToRegex("H", 4), 
+                    utilDate.formatCodeToRegex("i", 5), 
+                    utilDate.formatCodeToRegex("s", 6), 
+                    {c:"ms = results[7] || '0'; ms = parseInt(ms, 10)/Math.pow(10, ms.length - 3);\n"}, 
+                    {c:[ 
+                        "if(results[8]) {", 
+                            "if(results[8] == 'Z'){",
+                                "zz = 0;", 
+                            "}else if (results[8].indexOf(':') > -1){",
+                                utilDate.formatCodeToRegex("P", 8).c, 
+                            "}else{",
+                                utilDate.formatCodeToRegex("O", 8).c, 
+                            "}",
+                        "}"
+                    ].join('\n')}
+                ],
+                i,
+                l;
+
+            for (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, ")?", 
+                                "(?:(?:\\.|,)(\\d+))?", 
+                                "(Z|(?:[-+]\\d{2}(?::)?\\d{2}))?", 
+                            ")?",
+                        ")?",
+                    ")?"
+                ].join("")
+            };
+        },
+        U: {
+            g:1,
+            c:"u = parseInt(results[{0}], 10);\n",
+            s:"(-?\\d+)" 
+        }
+    },
+
+    
+    
+    dateFormat: function(date, format) {
+        return utilDate.format(date, format);
+    },
+
+    
+    isEqual: function(date1, date2) {
+        
+        if (date1 && date2) {
+            return (date1.getTime() === date2.getTime());
+        }
+        
+        return !(date1 || date2);
+    },
+
+    
+    format: function(date, format) {
+        var formatFunctions = utilDate.formatFunctions;
+
+        if (!Ext.isDate(date)) {
+            return '';
+        }
+
+        if (formatFunctions[format] == null) {
+            utilDate.createFormat(format);
+        }
+
+        return formatFunctions[format].call(date) + '';
+    },
+
+    
+    getTimezone : function(date) {
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        return date.toString().replace(/^.* (?:\((.*)\)|([A-Z]{1,4})(?:[\-+][0-9]{4})?(?: -?\d+)?)$/, "$1$2").replace(/[^A-Z]/g, "");
+    },
+
+    
+    getGMTOffset : function(date, colon) {
+        var offset = date.getTimezoneOffset();
+        return (offset > 0 ? "-" : "+")
+            + Ext.String.leftPad(Math.floor(Math.abs(offset) / 60), 2, "0")
+            + (colon ? ":" : "")
+            + Ext.String.leftPad(Math.abs(offset % 60), 2, "0");
+    },
+
+    
+    getDayOfYear: function(date) {
+        var num = 0,
+            d = Ext.Date.clone(date),
+            m = date.getMonth(),
+            i;
+
+        for (i = 0, d.setDate(1), d.setMonth(0); i < m; d.setMonth(++i)) {
+            num += utilDate.getDaysInMonth(d);
+        }
+        return num + date.getDate() - 1;
+    },
+
+    
+    getWeekOfYear : (function() {
+        
+        var ms1d = 864e5, 
+            ms7d = 7 * ms1d; 
+
+        return function(date) { 
+            var DC3 = Date.UTC(date.getFullYear(), date.getMonth(), date.getDate() + 3) / ms1d, 
+                AWN = Math.floor(DC3 / 7), 
+                Wyr = new Date(AWN * ms7d).getUTCFullYear();
+
+            return AWN - Math.floor(Date.UTC(Wyr, 0, 7) / ms7d) + 1;
+        };
+    }()),
+
+    
+    isLeapYear : function(date) {
+        var year = date.getFullYear();
+        return !!((year & 3) == 0 && (year % 100 || (year % 400 == 0 && year)));
+    },
+
+    
+    getFirstDayOfMonth : function(date) {
+        var day = (date.getDay() - (date.getDate() - 1)) % 7;
+        return (day < 0) ? (day + 7) : day;
+    },
+
+    
+    getLastDayOfMonth : function(date) {
+        return utilDate.getLastDateOfMonth(date).getDay();
+    },
+
+
+    
+    getFirstDateOfMonth : function(date) {
+        return new Date(date.getFullYear(), date.getMonth(), 1);
+    },
+
+    
+    getLastDateOfMonth : function(date) {
+        return new Date(date.getFullYear(), date.getMonth(), utilDate.getDaysInMonth(date));
+    },
+
+    
+    getDaysInMonth: (function() {
+        var daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+
+        return function(date) { 
+            var m = date.getMonth();
+
+            return m == 1 && utilDate.isLeapYear(date) ? 29 : daysInMonth[m];
+        };
+    }()),
+
+    
+    
+    getSuffix : function(date) {
+        switch (date.getDate()) {
+            case 1:
+            case 21:
+            case 31:
+                return "st";
+            case 2:
+            case 22:
+                return "nd";
+            case 3:
+            case 23:
+                return "rd";
+            default:
+                return "th";
+        }
+    },
+    
+
+    
+    clone : function(date) {
+        return new Date(date.getTime());
+    },
+
+    
+    isDST : function(date) {
+        
+        
+        return new Date(date.getFullYear(), 0, 1).getTimezoneOffset() != date.getTimezoneOffset();
+    },
+
+    
+    clearTime : function(date, clone) {
+        if (clone) {
+            return Ext.Date.clearTime(Ext.Date.clone(date));
+        }
+
+        
+        var d = date.getDate(),
+            hr,
+            c;
+
+        
+        date.setHours(0);
+        date.setMinutes(0);
+        date.setSeconds(0);
+        date.setMilliseconds(0);
+
+        if (date.getDate() != d) { 
+            
+            
+
+            
+            for (hr = 1, c = utilDate.add(date, Ext.Date.HOUR, hr); c.getDate() != d; hr++, c = utilDate.add(date, Ext.Date.HOUR, hr));
+
+            date.setDate(d);
+            date.setHours(c.getHours());
+        }
+
+        return date;
+    },
+
+    
+    add : function(date, interval, value) {
+        var d = Ext.Date.clone(date),
+            Date = Ext.Date,
+            day;
+        if (!interval || value === 0) {
+            return d;
+        }
+
+        switch(interval.toLowerCase()) {
+            case Ext.Date.MILLI:
+                d.setMilliseconds(d.getMilliseconds() + value);
+                break;
+            case Ext.Date.SECOND:
+                d.setSeconds(d.getSeconds() + value);
+                break;
+            case Ext.Date.MINUTE:
+                d.setMinutes(d.getMinutes() + value);
+                break;
+            case Ext.Date.HOUR:
+                d.setHours(d.getHours() + value);
+                break;
+            case Ext.Date.DAY:
+                d.setDate(d.getDate() + value);
+                break;
+            case Ext.Date.MONTH:
+                day = date.getDate();
+                if (day > 28) {
+                    day = Math.min(day, Ext.Date.getLastDateOfMonth(Ext.Date.add(Ext.Date.getFirstDateOfMonth(date), Ext.Date.MONTH, value)).getDate());
+                }
+                d.setDate(day);
+                d.setMonth(date.getMonth() + value);
+                break;
+            case Ext.Date.YEAR:
+                day = date.getDate();
+                if (day > 28) {
+                    day = Math.min(day, Ext.Date.getLastDateOfMonth(Ext.Date.add(Ext.Date.getFirstDateOfMonth(date), Ext.Date.YEAR, value)).getDate());
+                }
+                d.setDate(day);
+                d.setFullYear(date.getFullYear() + value);
+                break;
+        }
+        return d;
+    },
+
+    
+    between : function(date, start, end) {
+        var t = date.getTime();
+        return start.getTime() <= t && t <= end.getTime();
+    },
+
+    
+    compat: function() {
+        var nativeDate = window.Date,
+            p, u,
+            statics = ['useStrict', 'formatCodeToRegex', 'parseFunctions', 'parseRegexes', 'formatFunctions', 'y2kYear', 'MILLI', 'SECOND', 'MINUTE', 'HOUR', 'DAY', 'MONTH', 'YEAR', 'defaults', 'dayNames', 'monthNames', 'monthNumbers', 'getShortMonthName', 'getShortDayName', 'getMonthNumber', 'formatCodes', 'isValid', 'parseDate', 'getFormatCode', 'createFormat', 'createParser', 'parseCodes'],
+            proto = ['dateFormat', 'format', 'getTimezone', 'getGMTOffset', 'getDayOfYear', 'getWeekOfYear', 'isLeapYear', 'getFirstDayOfMonth', 'getLastDayOfMonth', 'getDaysInMonth', 'getSuffix', 'clone', 'isDST', 'clearTime', 'add', 'between'],
+            sLen    = statics.length,
+            pLen    = proto.length,
+            stat, prot, s;
+
+        
+        for (s = 0; s < sLen; s++) {
+            stat = statics[s];
+            nativeDate[stat] = utilDate[stat];
+        }
+
+        
+        for (p = 0; p < pLen; p++) {
+            prot = proto[p];
+            nativeDate.prototype[prot] = function() {
+                var args = Array.prototype.slice.call(arguments);
+                args.unshift(this);
+                return utilDate[prot].apply(utilDate, args);
+            };
+        }
+    }
+};
+
+var utilDate = Ext.Date;
+
+}());
+
+//@tag foundation,core
+
+//@require ../lang/Date.js
+
+
+
+(function(flexSetter) {
+
+var noArgs = [],
+    Base = function(){};
+
+    
+    Ext.apply(Base, {
+        $className: 'Ext.Base',
+
+        $isClass: true,
+
+        
+        create: function() {
+            return Ext.create.apply(Ext, [this].concat(Array.prototype.slice.call(arguments, 0)));
+        },
+
+        
+        extend: function(parent) {
+            var parentPrototype = parent.prototype,
+                basePrototype, prototype, i, ln, name, statics;
+
+            prototype = this.prototype = Ext.Object.chain(parentPrototype);
+            prototype.self = this;
+
+            this.superclass = prototype.superclass = parentPrototype;
+
+            if (!parent.$isClass) {
+                basePrototype = Ext.Base.prototype;
+
+                for (i in basePrototype) {
+                    if (i in prototype) {
+                        prototype[i] = basePrototype[i];
+                    }
+                }
+            }
+
+            
+            statics = parentPrototype.$inheritableStatics;
+
+            if (statics) {
+                for (i = 0,ln = statics.length; i < ln; i++) {
+                    name = statics[i];
+
+                    if (!this.hasOwnProperty(name)) {
+                        this[name] = parent[name];
+                    }
+                }
+            }
+
+            if (parent.$onExtended) {
+                this.$onExtended = parent.$onExtended.slice();
+            }
+
+            prototype.config = new prototype.configClass();
+            prototype.initConfigList = prototype.initConfigList.slice();
+            prototype.initConfigMap = Ext.clone(prototype.initConfigMap);
+            prototype.configMap = Ext.Object.chain(prototype.configMap);
+        },
+
+        
+        $onExtended: [],
+
+        
+        triggerExtended: function() {
+            var callbacks = this.$onExtended,
+                ln = callbacks.length,
+                i, callback;
+
+            if (ln > 0) {
+                for (i = 0; i < ln; i++) {
+                    callback = callbacks[i];
+                    callback.fn.apply(callback.scope || this, arguments);
+                }
+            }
+        },
+
+        
+        onExtended: function(fn, scope) {
+            this.$onExtended.push({
+                fn: fn,
+                scope: scope
+            });
+
+            return this;
+        },
+
+        
+        addConfig: function(config, fullMerge) {
+            var prototype = this.prototype,
+                configNameCache = Ext.Class.configNameCache,
+                hasConfig = prototype.configMap,
+                initConfigList = prototype.initConfigList,
+                initConfigMap = prototype.initConfigMap,
+                defaultConfig = prototype.config,
+                initializedName, name, value;
+
+            for (name in config) {
+                if (config.hasOwnProperty(name)) {
+                    if (!hasConfig[name]) {
+                        hasConfig[name] = true;
+                    }
+
+                    value = config[name];
+
+                    initializedName = configNameCache[name].initialized;
+
+                    if (!initConfigMap[name] && value !== null && !prototype[initializedName]) {
+                        initConfigMap[name] = true;
+                        initConfigList.push(name);
+                    }
+                }
+            }
+
+            if (fullMerge) {
+                Ext.merge(defaultConfig, config);
+            }
+            else {
+                Ext.mergeIf(defaultConfig, config);
+            }
+
+            prototype.configClass = Ext.Object.classify(defaultConfig);
+        },
+
+        
+        addStatics: function(members) {
+            var member, name;
+
+            for (name in members) {
+                if (members.hasOwnProperty(name)) {
+                    member = members[name];
+                    if (typeof member == 'function' && !member.$isClass && member !== Ext.emptyFn && member !== Ext.identityFn) {
+                        member.$owner = this;
+                        member.$name = name;
+                    }
+                    this[name] = member;
+                }
+            }
+
+            return this;
+        },
+
+        
+        addInheritableStatics: function(members) {
+            var inheritableStatics,
+                hasInheritableStatics,
+                prototype = this.prototype,
+                name, member;
+
+            inheritableStatics = prototype.$inheritableStatics;
+            hasInheritableStatics = prototype.$hasInheritableStatics;
+
+            if (!inheritableStatics) {
+                inheritableStatics = prototype.$inheritableStatics = [];
+                hasInheritableStatics = prototype.$hasInheritableStatics = {};
+            }
+
+            for (name in members) {
+                if (members.hasOwnProperty(name)) {
+                    member = members[name];
+                    this[name] = member;
+
+                    if (!hasInheritableStatics[name]) {
+                        hasInheritableStatics[name] = true;
+                        inheritableStatics.push(name);
+                    }
+                }
+            }
+
+            return this;
+        },
+
+        
+        addMembers: function(members) {
+            var prototype = this.prototype,
+                enumerables = Ext.enumerables,
+                names = [],
+                i, ln, name, member;
+
+            for (name in members) {
+                names.push(name);
+            }
+
+            if (enumerables) {
+                names.push.apply(names, enumerables);
+            }
+
+            for (i = 0,ln = names.length; i < ln; i++) {
+                name = names[i];
+
+                if (members.hasOwnProperty(name)) {
+                    member = members[name];
+
+                    if (typeof member == 'function' && !member.$isClass && member !== Ext.emptyFn) {
+                        member.$owner = this;
+                        member.$name = name;
+                    }
+
+                    prototype[name] = member;
+                }
+            }
+
+            return this;
+        },
+
+        
+        addMember: function(name, member) {
+            if (typeof member == 'function' && !member.$isClass && member !== Ext.emptyFn) {
+                member.$owner = this;
+                member.$name = name;
+            }
+
+            this.prototype[name] = member;
+
+            return this;
+        },
+
+        
+        implement: function() {
+            this.addMembers.apply(this, arguments);
+        },
+
+        
+        borrow: function(fromClass, members) {
+            var prototype = this.prototype,
+                fromPrototype = fromClass.prototype,
+                i, ln, name, fn, toBorrow;
+
+            members = Ext.Array.from(members);
+
+            for (i = 0,ln = members.length; i < ln; i++) {
+                name = members[i];
+
+                toBorrow = fromPrototype[name];
+
+                if (typeof toBorrow == 'function') {
+                    fn = Ext.Function.clone(toBorrow);
+
+
+                    fn.$owner = this;
+                    fn.$name = name;
+
+                    prototype[name] = fn;
+                }
+                else {
+                    prototype[name] = toBorrow;
+                }
+            }
+
+            return this;
+        },
+
+        
+        override: function(members) {
+            var me = this,
+                enumerables = Ext.enumerables,
+                target = me.prototype,
+                cloneFunction = Ext.Function.clone,
+                name, index, member, statics, names, previous;
+
+            if (arguments.length === 2) {
+                name = members;
+                members = {};
+                members[name] = arguments[1];
+                enumerables = null;
+            }
+
+            do {
+                names = []; 
+                statics = null; 
+
+                for (name in members) { 
+                    if (name == 'statics') {
+                        statics = members[name];
+                    } else if (name == 'config') {
+                        me.addConfig(members[name], true);
+                    } else {
+                        names.push(name);
+                    }
+                }
+
+                if (enumerables) {
+                    names.push.apply(names, enumerables);
+                }
+
+                for (index = names.length; index--; ) {
+                    name = names[index];
+
+                    if (members.hasOwnProperty(name)) {
+                        member = members[name];
+
+                        if (typeof member == 'function' && !member.$className && member !== Ext.emptyFn) {
+                            if (typeof member.$owner != 'undefined') {
+                                member = cloneFunction(member);
+                            }
+
+
+                            member.$owner = me;
+                            member.$name = name;
+
+                            previous = target[name];
+                            if (previous) {
+                                member.$previous = previous;
+                            }
+                        }
+
+                        target[name] = member;
+                    }
+                }
+
+                target = me; 
+                members = statics; 
+            } while (members);
+
+            return this;
+        },
+
+        
+        callParent: function(args) {
+            var method;
+
+            
+            return (method = this.callParent.caller) && (method.$previous ||
+                ((method = method.$owner ? method : method.caller) &&
+                    method.$owner.superclass.self[method.$name])).apply(this, args || noArgs);
+        },
+
+        
+        callSuper: function(args) {
+            var method;
+
+            
+            return (method = this.callSuper.caller) &&
+                ((method = method.$owner ? method : method.caller) &&
+                    method.$owner.superclass.self[method.$name]).apply(this, args || noArgs);
+        },
+
+        
+        mixin: function(name, mixinClass) {
+            var mixin = mixinClass.prototype,
+                prototype = this.prototype,
+                key;
+
+            if (typeof mixin.onClassMixedIn != 'undefined') {
+                mixin.onClassMixedIn.call(mixinClass, this);
+            }
+
+            if (!prototype.hasOwnProperty('mixins')) {
+                if ('mixins' in prototype) {
+                    prototype.mixins = Ext.Object.chain(prototype.mixins);
+                }
+                else {
+                    prototype.mixins = {};
+                }
+            }
+
+            for (key in mixin) {
+                if (key === 'mixins') {
+                    Ext.merge(prototype.mixins, mixin[key]);
+                }
+                else if (typeof prototype[key] == 'undefined' && key != 'mixinId' && key != 'config') {
+                    prototype[key] = mixin[key];
+                }
+            }
+
+            if ('config' in mixin) {
+                this.addConfig(mixin.config, false);
+            }
+
+            prototype.mixins[name] = mixin;
+        },
+
+        
+        getName: function() {
+            return Ext.getClassName(this);
+        },
+
+        
+        createAlias: flexSetter(function(alias, origin) {
+            this.override(alias, function() {
+                return this[origin].apply(this, arguments);
+            });
+        }),
+
+        
+        addXtype: function(xtype) {
+            var prototype = this.prototype,
+                xtypesMap = prototype.xtypesMap,
+                xtypes = prototype.xtypes,
+                xtypesChain = prototype.xtypesChain;
+
+            if (!prototype.hasOwnProperty('xtypesMap')) {
+                xtypesMap = prototype.xtypesMap = Ext.merge({}, prototype.xtypesMap || {});
+                xtypes = prototype.xtypes = prototype.xtypes ? [].concat(prototype.xtypes) : [];
+                xtypesChain = prototype.xtypesChain = prototype.xtypesChain ? [].concat(prototype.xtypesChain) : [];
+                prototype.xtype = xtype;
+            }
+
+            if (!xtypesMap[xtype]) {
+                xtypesMap[xtype] = true;
+                xtypes.push(xtype);
+                xtypesChain.push(xtype);
+                Ext.ClassManager.setAlias(this, 'widget.' + xtype);
+            }
+
+            return this;
+        }
+    });
+
+    Base.implement({
+        
+        isInstance: true,
+
+        
+        $className: 'Ext.Base',
+
+        
+        configClass: Ext.emptyFn,
+
+        
+        initConfigList: [],
+
+        
+        configMap: {},
+
+        
+        initConfigMap: {},
+
+        
+        statics: function() {
+            var method = this.statics.caller,
+                self = this.self;
+
+            if (!method) {
+                return self;
+            }
+
+            return method.$owner;
+        },
+
+        
+        callParent: function(args) {
+            
+            
+            
+            
+            var method,
+                superMethod = (method = this.callParent.caller) && (method.$previous ||
+                        ((method = method.$owner ? method : method.caller) &&
+                                method.$owner.superclass[method.$name]));
+
+
+            return superMethod.apply(this, args || noArgs);
+        },
+
+        
+        callSuper: function(args) {
+            
+            
+            
+            
+            var method,
+                superMethod = (method = this.callSuper.caller) &&
+                    ((method = method.$owner ? method : method.caller) &&
+                        method.$owner.superclass[method.$name]);
+
+
+            return superMethod.apply(this, args || noArgs);
+        },
+
+        
+        self: Base,
+
+        
+        constructor: function() {
+            return this;
+        },
+
+        
+        initConfig: function(config) {
+            var instanceConfig = config,
+                configNameCache = Ext.Class.configNameCache,
+                defaultConfig = new this.configClass(),
+                defaultConfigList = this.initConfigList,
+                hasConfig = this.configMap,
+                nameMap, i, ln, name, initializedName;
+
+            this.initConfig = Ext.emptyFn;
+
+            this.initialConfig = instanceConfig || {};
+
+            this.config = config = (instanceConfig) ? Ext.merge(defaultConfig, config) : defaultConfig;
+
+            if (instanceConfig) {
+                defaultConfigList = defaultConfigList.slice();
+
+                for (name in instanceConfig) {
+                    if (hasConfig[name]) {
+                        if (instanceConfig[name] !== null) {
+                            defaultConfigList.push(name);
+                            this[configNameCache[name].initialized] = false;
+                        }
+                    }
+                }
+            }
+
+            for (i = 0,ln = defaultConfigList.length; i < ln; i++) {
+                name = defaultConfigList[i];
+                nameMap = configNameCache[name];
+                initializedName = nameMap.initialized;
+
+                if (!this[initializedName]) {
+                    this[initializedName] = true;
+                    this[nameMap.set].call(this, config[name]);
+                }
+            }
+
+            return this;
+        },
+
+        
+        hasConfig: function(name) {
+            return Boolean(this.configMap[name]);
+        },
+
+        
+        setConfig: function(config, applyIfNotSet) {
+            if (!config) {
+                return this;
+            }
+
+            var configNameCache = Ext.Class.configNameCache,
+                currentConfig = this.config,
+                hasConfig = this.configMap,
+                initialConfig = this.initialConfig,
+                name, value;
+
+            applyIfNotSet = Boolean(applyIfNotSet);
+
+            for (name in config) {
+                if (applyIfNotSet && initialConfig.hasOwnProperty(name)) {
+                    continue;
+                }
+
+                value = config[name];
+                currentConfig[name] = value;
+
+                if (hasConfig[name]) {
+                    this[configNameCache[name].set](value);
+                }
+            }
+
+            return this;
+        },
+
+        
+        getConfig: function(name) {
+            var configNameCache = Ext.Class.configNameCache;
+
+            return this[configNameCache[name].get]();
+        },
+
+        
+        getInitialConfig: function(name) {
+            var config = this.config;
+
+            if (!name) {
+                return config;
+            }
+            else {
+                return config[name];
+            }
+        },
+
+        
+        onConfigUpdate: function(names, callback, scope) {
+            var self = this.self,
+                i, ln, name,
+                updaterName, updater, newUpdater;
+
+            names = Ext.Array.from(names);
+
+            scope = scope || this;
+
+            for (i = 0,ln = names.length; i < ln; i++) {
+                name = names[i];
+                updaterName = 'update' + Ext.String.capitalize(name);
+                updater = this[updaterName] || Ext.emptyFn;
+                newUpdater = function() {
+                    updater.apply(this, arguments);
+                    scope[callback].apply(scope, arguments);
+                };
+                newUpdater.$name = updaterName;
+                newUpdater.$owner = self;
+
+                this[updaterName] = newUpdater;
+            }
+        },
+
+        
+        destroy: function() {
+            this.destroy = Ext.emptyFn;
+        }
+    });
+
+    
+    Base.prototype.callOverridden = Base.prototype.callParent;
+
+    Ext.Base = Base;
+
+}(Ext.Function.flexSetter));
+
+//@tag foundation,core
+
+//@require Base.js
+
+
+
+(function() {
+    var ExtClass,
+        Base = Ext.Base,
+        baseStaticMembers = [],
+        baseStaticMember, baseStaticMemberLength;
+
+    for (baseStaticMember in Base) {
+        if (Base.hasOwnProperty(baseStaticMember)) {
+            baseStaticMembers.push(baseStaticMember);
+        }
+    }
+
+    baseStaticMemberLength = baseStaticMembers.length;
+
+    
+    function makeCtor (className) {
+        function constructor () {
+            
+            
+            return this.constructor.apply(this, arguments) || null;
+        }
+        return constructor;
+    }
+
+    
+    Ext.Class = ExtClass = function(Class, data, onCreated) {
+        if (typeof Class != 'function') {
+            onCreated = data;
+            data = Class;
+            Class = null;
+        }
+
+        if (!data) {
+            data = {};
+        }
+
+        Class = ExtClass.create(Class, data);
+
+        ExtClass.process(Class, data, onCreated);
+
+        return Class;
+    };
+
+    Ext.apply(ExtClass, {
+        
+        onBeforeCreated: function(Class, data, hooks) {
+            Class.addMembers(data);
+
+            hooks.onCreated.call(Class, Class);
+        },
+
+        
+        create: function(Class, data) {
+            var name, i;
+
+            if (!Class) {
+                Class = makeCtor(
+                );
+            }
+
+            for (i = 0; i < baseStaticMemberLength; i++) {
+                name = baseStaticMembers[i];
+                Class[name] = Base[name];
+            }
+
+            return Class;
+        },
+
+        
+        process: function(Class, data, onCreated) {
+            var preprocessorStack = data.preprocessors || ExtClass.defaultPreprocessors,
+                registeredPreprocessors = this.preprocessors,
+                hooks = {
+                    onBeforeCreated: this.onBeforeCreated
+                },
+                preprocessors = [],
+                preprocessor, preprocessorsProperties,
+                i, ln, j, subLn, preprocessorProperty, process;
+
+            delete data.preprocessors;
+
+            for (i = 0,ln = preprocessorStack.length; i < ln; i++) {
+                preprocessor = preprocessorStack[i];
+
+                if (typeof preprocessor == 'string') {
+                    preprocessor = registeredPreprocessors[preprocessor];
+                    preprocessorsProperties = preprocessor.properties;
+
+                    if (preprocessorsProperties === true) {
+                        preprocessors.push(preprocessor.fn);
+                    }
+                    else if (preprocessorsProperties) {
+                        for (j = 0,subLn = preprocessorsProperties.length; j < subLn; j++) {
+                            preprocessorProperty = preprocessorsProperties[j];
+
+                            if (data.hasOwnProperty(preprocessorProperty)) {
+                                preprocessors.push(preprocessor.fn);
+                                break;
+                            }
+                        }
+                    }
+                }
+                else {
+                    preprocessors.push(preprocessor);
+                }
+            }
+
+            hooks.onCreated = onCreated ? onCreated : Ext.emptyFn;
+            hooks.preprocessors = preprocessors;
+
+            this.doProcess(Class, data, hooks);
+        },
+        
+        doProcess: function(Class, data, hooks){
+            var me = this,
+                preprocessor = hooks.preprocessors.shift();
+
+            if (!preprocessor) {
+                hooks.onBeforeCreated.apply(me, arguments);
+                return;
+            }
+
+            if (preprocessor.call(me, Class, data, hooks, me.doProcess) !== false) {
+                me.doProcess(Class, data, hooks);
+            }
+        },
+
+        
+        preprocessors: {},
+
+        
+        registerPreprocessor: function(name, fn, properties, position, relativeTo) {
+            if (!position) {
+                position = 'last';
+            }
+
+            if (!properties) {
+                properties = [name];
+            }
+
+            this.preprocessors[name] = {
+                name: name,
+                properties: properties || false,
+                fn: fn
+            };
+
+            this.setDefaultPreprocessorPosition(name, position, relativeTo);
+
+            return this;
+        },
+
+        
+        getPreprocessor: function(name) {
+            return this.preprocessors[name];
+        },
+
+        
+        getPreprocessors: function() {
+            return this.preprocessors;
+        },
+
+        
+        defaultPreprocessors: [],
+
+        
+        getDefaultPreprocessors: function() {
+            return this.defaultPreprocessors;
+        },
+
+        
+        setDefaultPreprocessors: function(preprocessors) {
+            this.defaultPreprocessors = Ext.Array.from(preprocessors);
+
+            return this;
+        },
+
+        
+        setDefaultPreprocessorPosition: function(name, offset, relativeName) {
+            var defaultPreprocessors = this.defaultPreprocessors,
+                index;
+
+            if (typeof offset == 'string') {
+                if (offset === 'first') {
+                    defaultPreprocessors.unshift(name);
+
+                    return this;
+                }
+                else if (offset === 'last') {
+                    defaultPreprocessors.push(name);
+
+                    return this;
+                }
+
+                offset = (offset === 'after') ? 1 : -1;
+            }
+
+            index = Ext.Array.indexOf(defaultPreprocessors, relativeName);
+
+            if (index !== -1) {
+                Ext.Array.splice(defaultPreprocessors, Math.max(0, index + offset), 0, name);
+            }
+
+            return this;
+        },
+
+        configNameCache: {},
+
+        getConfigNameMap: function(name) {
+            var cache = this.configNameCache,
+                map = cache[name],
+                capitalizedName;
+
+            if (!map) {
+                capitalizedName = name.charAt(0).toUpperCase() + name.substr(1);
+
+                map = cache[name] = {
+                    internal: name,
+                    initialized: '_is' + capitalizedName + 'Initialized',
+                    apply: 'apply' + capitalizedName,
+                    update: 'update' + capitalizedName,
+                    'set': 'set' + capitalizedName,
+                    'get': 'get' + capitalizedName,
+                    doSet : 'doSet' + capitalizedName,
+                    changeEvent: name.toLowerCase() + 'change'
+                };
+            }
+
+            return map;
+        }
+    });
+
+    
+    ExtClass.registerPreprocessor('extend', function(Class, data) {
+        var Base = Ext.Base,
+            basePrototype = Base.prototype,
+            extend = data.extend,
+            Parent, parentPrototype, i;
+
+        delete data.extend;
+
+        if (extend && extend !== Object) {
+            Parent = extend;
+        }
+        else {
+            Parent = Base;
+        }
+
+        parentPrototype = Parent.prototype;
+
+        if (!Parent.$isClass) {
+            for (i in basePrototype) {
+                if (!parentPrototype[i]) {
+                    parentPrototype[i] = basePrototype[i];
+                }
+            }
+        }
+
+        Class.extend(Parent);
+
+        Class.triggerExtended.apply(Class, arguments);
+
+        if (data.onClassExtended) {
+            Class.onExtended(data.onClassExtended, Class);
+            delete data.onClassExtended;
+        }
+
+    }, true);
+
+    
+    ExtClass.registerPreprocessor('statics', function(Class, data) {
+        Class.addStatics(data.statics);
+
+        delete data.statics;
+    });
+
+    
+    ExtClass.registerPreprocessor('inheritableStatics', function(Class, data) {
+        Class.addInheritableStatics(data.inheritableStatics);
+
+        delete data.inheritableStatics;
+    });
+
+    
+    ExtClass.registerPreprocessor('config', function(Class, data) {
+        var config = data.config,
+            prototype = Class.prototype;
+
+        delete data.config;
+
+        Ext.Object.each(config, function(name, value) {
+            var nameMap = ExtClass.getConfigNameMap(name),
+                internalName = nameMap.internal,
+                initializedName = nameMap.initialized,
+                applyName = nameMap.apply,
+                updateName = nameMap.update,
+                setName = nameMap.set,
+                getName = nameMap.get,
+                hasOwnSetter = (setName in prototype) || data.hasOwnProperty(setName),
+                hasOwnApplier = (applyName in prototype) || data.hasOwnProperty(applyName),
+                hasOwnUpdater = (updateName in prototype) || data.hasOwnProperty(updateName),
+                optimizedGetter, customGetter;
+
+            if (value === null || (!hasOwnSetter && !hasOwnApplier && !hasOwnUpdater)) {
+                prototype[internalName] = value;
+                prototype[initializedName] = true;
+            }
+            else {
+                prototype[initializedName] = false;
+            }
+
+            if (!hasOwnSetter) {
+                data[setName] = function(value) {
+                    var oldValue = this[internalName],
+                        applier = this[applyName],
+                        updater = this[updateName];
+
+                    if (!this[initializedName]) {
+                        this[initializedName] = true;
+                    }
+
+                    if (applier) {
+                        value = applier.call(this, value, oldValue);
+                    }
+
+                    if (typeof value != 'undefined') {
+                        this[internalName] = value;
+
+                        if (updater && value !== oldValue) {
+                            updater.call(this, value, oldValue);
+                        }
+                    }
+
+                    return this;
+                };
+            }
+
+            if (!(getName in prototype) || data.hasOwnProperty(getName)) {
+                customGetter = data[getName] || false;
+
+                if (customGetter) {
+                    optimizedGetter = function() {
+                        return customGetter.apply(this, arguments);
+                    };
+                }
+                else {
+                    optimizedGetter = function() {
+                        return this[internalName];
+                    };
+                }
+
+                data[getName] = function() {
+                    var currentGetter;
+
+                    if (!this[initializedName]) {
+                        this[initializedName] = true;
+                        this[setName](this.config[name]);
+                    }
+
+                    currentGetter = this[getName];
+
+                    if ('$previous' in currentGetter) {
+                        currentGetter.$previous = optimizedGetter;
+                    }
+                    else {
+                        this[getName] = optimizedGetter;
+                    }
+
+                    return optimizedGetter.apply(this, arguments);
+                };
+            }
+        });
+
+        Class.addConfig(config, true);
+    });
+
+    
+    ExtClass.registerPreprocessor('mixins', function(Class, data, hooks) {
+        var mixins = data.mixins,
+            name, mixin, i, ln;
+
+        delete data.mixins;
+
+        Ext.Function.interceptBefore(hooks, 'onCreated', function() {
+            if (mixins instanceof Array) {
+                for (i = 0,ln = mixins.length; i < ln; i++) {
+                    mixin = mixins[i];
+                    name = mixin.prototype.mixinId || mixin.$className;
+
+                    Class.mixin(name, mixin);
+                }
+            }
+            else {
+                for (var mixinName in mixins) {
+                    if (mixins.hasOwnProperty(mixinName)) {
+                        Class.mixin(mixinName, mixins[mixinName]);
+                    }
+                }
+            }
+        });
+    });
+
+    
+    Ext.extend = function(Class, Parent, members) {
+        if (arguments.length === 2 && Ext.isObject(Parent)) {
+            members = Parent;
+            Parent = Class;
+            Class = null;
+        }
+
+        var cls;
+
+        if (!Parent) {
+            throw new Error("[Ext.extend] Attempting to extend from a class which has not been loaded on the page.");
+        }
+
+        members.extend = Parent;
+        members.preprocessors = [
+            'extend'
+            ,'statics'
+            ,'inheritableStatics'
+            ,'mixins'
+            ,'config'
+        ];
+
+        if (Class) {
+            cls = new ExtClass(Class, members);
+            
+            cls.prototype.constructor = Class;
+        } else {
+            cls = new ExtClass(members);
+        }
+
+        cls.prototype.override = function(o) {
+            for (var m in o) {
+                if (o.hasOwnProperty(m)) {
+                    this[m] = o[m];
+                }
+            }
+        };
+
+        return cls;
+    };
+
+}());
+
+//@tag foundation,core
+
+//@require Class.js
+
+
+
+(function(Class, alias, arraySlice, arrayFrom, global) {
+
+    
+    function makeCtor () {
+        function constructor () {
+            
+            
+            return this.constructor.apply(this, arguments) || null;
+        }
+        return constructor;
+    }
+
+    var Manager = Ext.ClassManager = {
+
+        
+        classes: {},
+
+        
+        existCache: {},
+
+        
+        namespaceRewrites: [{
+            from: 'Ext.',
+            to: Ext
+        }],
+
+        
+        maps: {
+            alternateToName: {},
+            aliasToName: {},
+            nameToAliases: {},
+            nameToAlternates: {}
+        },
+
+        
+        enableNamespaceParseCache: true,
+
+        
+        namespaceParseCache: {},
+
+        
+        instantiators: [],
+
+        
+        isCreated: function(className) {
+            var existCache = this.existCache,
+                i, ln, part, root, parts;
+
+
+            if (this.classes[className] || existCache[className]) {
+                return true;
+            }
+
+            root = global;
+            parts = this.parseNamespace(className);
+
+            for (i = 0, ln = parts.length; i < ln; i++) {
+                part = parts[i];
+
+                if (typeof part != 'string') {
+                    root = part;
+                } else {
+                    if (!root || !root[part]) {
+                        return false;
+                    }
+
+                    root = root[part];
+                }
+            }
+
+            existCache[className] = true;
+
+            this.triggerCreated(className);
+
+            return true;
+        },
+
+        
+        createdListeners: [],
+
+        
+        nameCreatedListeners: {},
+
+        
+        triggerCreated: function(className) {
+            var listeners = this.createdListeners,
+                nameListeners = this.nameCreatedListeners,
+                alternateNames = this.maps.nameToAlternates[className],
+                names = [className],
+                i, ln, j, subLn, listener, name;
+
+            for (i = 0,ln = listeners.length; i < ln; i++) {
+                listener = listeners[i];
+                listener.fn.call(listener.scope, className);
+            }
+
+            if (alternateNames) {
+                names.push.apply(names, alternateNames);
+            }
+
+            for (i = 0,ln = names.length; i < ln; i++) {
+                name = names[i];
+                listeners = nameListeners[name];
+
+                if (listeners) {
+                    for (j = 0,subLn = listeners.length; j < subLn; j++) {
+                        listener = listeners[j];
+                        listener.fn.call(listener.scope, name);
+                    }
+                    delete nameListeners[name];
+                }
+            }
+        },
+
+        
+        onCreated: function(fn, scope, className) {
+            var listeners = this.createdListeners,
+                nameListeners = this.nameCreatedListeners,
+                listener = {
+                    fn: fn,
+                    scope: scope
+                };
+
+            if (className) {
+                if (this.isCreated(className)) {
+                    fn.call(scope, className);
+                    return;
+                }
+
+                if (!nameListeners[className]) {
+                    nameListeners[className] = [];
+                }
+
+                nameListeners[className].push(listener);
+            }
+            else {
+                listeners.push(listener);
+            }
+        },
+
+        
+        parseNamespace: function(namespace) {
+
+            var cache = this.namespaceParseCache,
+                parts,
+                rewrites,
+                root,
+                name,
+                rewrite, from, to, i, ln;
+
+            if (this.enableNamespaceParseCache) {
+                if (cache.hasOwnProperty(namespace)) {
+                    return cache[namespace];
+                }
+            }
+
+            parts = [];
+            rewrites = this.namespaceRewrites;
+            root = global;
+            name = namespace;
+
+            for (i = 0, ln = rewrites.length; i < ln; i++) {
+                rewrite = rewrites[i];
+                from = rewrite.from;
+                to = rewrite.to;
+
+                if (name === from || name.substring(0, from.length) === from) {
+                    name = name.substring(from.length);
+
+                    if (typeof to != 'string') {
+                        root = to;
+                    } else {
+                        parts = parts.concat(to.split('.'));
+                    }
+
+                    break;
+                }
+            }
+
+            parts.push(root);
+
+            parts = parts.concat(name.split('.'));
+
+            if (this.enableNamespaceParseCache) {
+                cache[namespace] = parts;
+            }
+
+            return parts;
+        },
+
+        
+        setNamespace: function(name, value) {
+            var root = global,
+                parts = this.parseNamespace(name),
+                ln = parts.length - 1,
+                leaf = parts[ln],
+                i, part;
+
+            for (i = 0; i < ln; i++) {
+                part = parts[i];
+
+                if (typeof part != 'string') {
+                    root = part;
+                } else {
+                    if (!root[part]) {
+                        root[part] = {};
+                    }
+
+                    root = root[part];
+                }
+            }
+
+            root[leaf] = value;
+
+            return root[leaf];
+        },
+
+        
+        createNamespaces: function() {
+            var root = global,
+                parts, part, i, j, ln, subLn;
+
+            for (i = 0, ln = arguments.length; i < ln; i++) {
+                parts = this.parseNamespace(arguments[i]);
+
+                for (j = 0, subLn = parts.length; j < subLn; j++) {
+                    part = parts[j];
+
+                    if (typeof part != 'string') {
+                        root = part;
+                    } else {
+                        if (!root[part]) {
+                            root[part] = {};
+                        }
+
+                        root = root[part];
+                    }
+                }
+            }
+
+            return root;
+        },
+
+        
+        set: function(name, value) {
+            var me = this,
+                maps = me.maps,
+                nameToAlternates = maps.nameToAlternates,
+                targetName = me.getName(value),
+                alternates;
+
+            me.classes[name] = me.setNamespace(name, value);
+
+            if (targetName && targetName !== name) {
+                maps.alternateToName[name] = targetName;
+                alternates = nameToAlternates[targetName] || (nameToAlternates[targetName] = []);
+                alternates.push(name);
+            }
+
+            return this;
+        },
+
+        
+        get: function(name) {
+            var classes = this.classes,
+                root,
+                parts,
+                part, i, ln;
+
+            if (classes[name]) {
+                return classes[name];
+            }
+
+            root = global;
+            parts = this.parseNamespace(name);
+
+            for (i = 0, ln = parts.length; i < ln; i++) {
+                part = parts[i];
+
+                if (typeof part != 'string') {
+                    root = part;
+                } else {
+                    if (!root || !root[part]) {
+                        return null;
+                    }
+
+                    root = root[part];
+                }
+            }
+
+            return root;
+        },
+
+        
+        setAlias: function(cls, alias) {
+            var aliasToNameMap = this.maps.aliasToName,
+                nameToAliasesMap = this.maps.nameToAliases,
+                className;
+
+            if (typeof cls == 'string') {
+                className = cls;
+            } else {
+                className = this.getName(cls);
+            }
+
+            if (alias && aliasToNameMap[alias] !== className) {
+
+                aliasToNameMap[alias] = className;
+            }
+
+            if (!nameToAliasesMap[className]) {
+                nameToAliasesMap[className] = [];
+            }
+
+            if (alias) {
+                Ext.Array.include(nameToAliasesMap[className], alias);
+            }
+
+            return this;
+        },
+
+        
+        addNameAliasMappings: function(aliases){
+            var aliasToNameMap = this.maps.aliasToName,
+                nameToAliasesMap = this.maps.nameToAliases,
+                className, aliasList, alias, i;
+
+            for (className in aliases) {
+                aliasList = nameToAliasesMap[className] ||
+                    (nameToAliasesMap[className] = []);
+
+                for (i = 0; i < aliases[className].length; i++) {
+                    alias = aliases[className][i];
+                    if (!aliasToNameMap[alias]) {
+                        aliasToNameMap[alias] = className;
+                        aliasList.push(alias);
+                    }
+                }
+
+            }
+            return this;
+        },
+
+        
+        addNameAlternateMappings: function(alternates) {
+            var alternateToName = this.maps.alternateToName,
+                nameToAlternates = this.maps.nameToAlternates,
+                className, aliasList, alternate, i;
+
+            for (className in alternates) {
+                aliasList = nameToAlternates[className] ||
+                    (nameToAlternates[className] = []);
+
+                for (i  = 0; i < alternates[className].length; i++) {
+                    alternate = alternates[className];
+                    if (!alternateToName[alternate]) {
+                        alternateToName[alternate] = className;
+                        aliasList.push(alternate);
+                    }
+                }
+
+            }
+            return this;
+        },
+
+        
+        getByAlias: function(alias) {
+            return this.get(this.getNameByAlias(alias));
+        },
+
+        
+        getNameByAlias: function(alias) {
+            return this.maps.aliasToName[alias] || '';
+        },
+
+        
+        getNameByAlternate: function(alternate) {
+            return this.maps.alternateToName[alternate] || '';
+        },
+
+        
+        getAliasesByName: function(name) {
+            return this.maps.nameToAliases[name] || [];
+        },
+
+        
+        getName: function(object) {
+            return object && object.$className || '';
+        },
+
+        
+        getClass: function(object) {
+            return object && object.self || null;
+        },
+
+        
+        create: function(className, data, createdFn) {
+
+            var ctor = makeCtor();
+            if (typeof data == 'function') {
+                data = data(ctor);
+            }
+
+
+            data.$className = className;
+
+            return new Class(ctor, data, function() {
+                var postprocessorStack = data.postprocessors || Manager.defaultPostprocessors,
+                    registeredPostprocessors = Manager.postprocessors,
+                    postprocessors = [],
+                    postprocessor, i, ln, j, subLn, postprocessorProperties, postprocessorProperty;
+
+                delete data.postprocessors;
+
+                for (i = 0,ln = postprocessorStack.length; i < ln; i++) {
+                    postprocessor = postprocessorStack[i];
+
+                    if (typeof postprocessor == 'string') {
+                        postprocessor = registeredPostprocessors[postprocessor];
+                        postprocessorProperties = postprocessor.properties;
+
+                        if (postprocessorProperties === true) {
+                            postprocessors.push(postprocessor.fn);
+                        }
+                        else if (postprocessorProperties) {
+                            for (j = 0,subLn = postprocessorProperties.length; j < subLn; j++) {
+                                postprocessorProperty = postprocessorProperties[j];
+
+                                if (data.hasOwnProperty(postprocessorProperty)) {
+                                    postprocessors.push(postprocessor.fn);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        postprocessors.push(postprocessor);
+                    }
+                }
+
+                data.postprocessors = postprocessors;
+                data.createdFn = createdFn;
+                Manager.processCreate(className, this, data);
+            });
+        },
+        
+        processCreate: function(className, cls, clsData){
+            var me = this,
+                postprocessor = clsData.postprocessors.shift(),
+                createdFn = clsData.createdFn;
+
+            if (!postprocessor) {
+                if (className) {
+                    me.set(className, cls);
+                }
+
+                if (createdFn) {
+                    createdFn.call(cls, cls);
+                }
+
+                if (className) {
+                    me.triggerCreated(className);
+                }
+                return;
+            }
+
+            if (postprocessor.call(me, className, cls, clsData, me.processCreate) !== false) {
+                me.processCreate(className, cls, clsData);
+            }
+        },
+
+        createOverride: function (className, data, createdFn) {
+            var me = this,
+                overriddenClassName = data.override,
+                requires = data.requires,
+                uses = data.uses,
+                classReady = function () {
+                    var cls, temp;
+
+                    if (requires) {
+                        temp = requires;
+                        requires = null; 
+
+                        
+                        
+                        
+                        Ext.Loader.require(temp, classReady);
+                    } else {
+                        
+                        
+                        cls = me.get(overriddenClassName);
+
+                        
+                        delete data.override;
+                        delete data.requires;
+                        delete data.uses;
+
+                        Ext.override(cls, data);
+
+                        
+                        
+                        
+                        me.triggerCreated(className);
+
+                        if (uses) {
+                            Ext.Loader.addUsedClasses(uses); 
+                        }
+
+                        if (createdFn) {
+                            createdFn.call(cls); 
+                        }
+                    }
+                };
+
+            me.existCache[className] = true;
+
+            
+            me.onCreated(classReady, me, overriddenClassName);
+ 
+            return me;
+        },
+
+        
+        instantiateByAlias: function() {
+            var alias = arguments[0],
+                args = arraySlice.call(arguments),
+                className = this.getNameByAlias(alias);
+
+            if (!className) {
+                className = this.maps.aliasToName[alias];
+
+
+
+                Ext.syncRequire(className);
+            }
+
+            args[0] = className;
+
+            return this.instantiate.apply(this, args);
+        },
+
+        
+        instantiate: function() {
+            var name = arguments[0],
+                nameType = typeof name,
+                args = arraySlice.call(arguments, 1),
+                alias = name,
+                possibleName, cls;
+
+            if (nameType != 'function') {
+                if (nameType != 'string' && args.length === 0) {
+                    args = [name];
+                    name = name.xclass;
+                }
+
+
+                cls = this.get(name);
+            }
+            else {
+                cls = name;
+            }
+
+            
+            if (!cls) {
+                possibleName = this.getNameByAlias(name);
+
+                if (possibleName) {
+                    name = possibleName;
+
+                    cls = this.get(name);
+                }
+            }
+
+            
+            if (!cls) {
+                possibleName = this.getNameByAlternate(name);
+
+                if (possibleName) {
+                    name = possibleName;
+
+                    cls = this.get(name);
+                }
+            }
+
+            
+            if (!cls) {
+
+                Ext.syncRequire(name);
+
+                cls = this.get(name);
+            }
+
+
+            return this.getInstantiator(args.length)(cls, args);
+        },
+
+        
+        dynInstantiate: function(name, args) {
+            args = arrayFrom(args, true);
+            args.unshift(name);
+
+            return this.instantiate.apply(this, args);
+        },
+
+        
+        getInstantiator: function(length) {
+            var instantiators = this.instantiators,
+                instantiator,
+                i,
+                args;
+
+            instantiator = instantiators[length];
+
+            if (!instantiator) {
+                i = length;
+                args = [];
+
+                for (i = 0; i < length; i++) {
+                    args.push('a[' + i + ']');
+                }
+
+                instantiator = instantiators[length] = new Function('c', 'a', 'return new c(' + args.join(',') + ')');
+            }
+
+            return instantiator;
+        },
+
+        
+        postprocessors: {},
+
+        
+        defaultPostprocessors: [],
+
+        
+        registerPostprocessor: function(name, fn, properties, position, relativeTo) {
+            if (!position) {
+                position = 'last';
+            }
+
+            if (!properties) {
+                properties = [name];
+            }
+
+            this.postprocessors[name] = {
+                name: name,
+                properties: properties || false,
+                fn: fn
+            };
+
+            this.setDefaultPostprocessorPosition(name, position, relativeTo);
+
+            return this;
+        },
+
+        
+        setDefaultPostprocessors: function(postprocessors) {
+            this.defaultPostprocessors = arrayFrom(postprocessors);
+
+            return this;
+        },
+
+        
+        setDefaultPostprocessorPosition: function(name, offset, relativeName) {
+            var defaultPostprocessors = this.defaultPostprocessors,
+                index;
+
+            if (typeof offset == 'string') {
+                if (offset === 'first') {
+                    defaultPostprocessors.unshift(name);
+
+                    return this;
+                }
+                else if (offset === 'last') {
+                    defaultPostprocessors.push(name);
+
+                    return this;
+                }
+
+                offset = (offset === 'after') ? 1 : -1;
+            }
+
+            index = Ext.Array.indexOf(defaultPostprocessors, relativeName);
+
+            if (index !== -1) {
+                Ext.Array.splice(defaultPostprocessors, Math.max(0, index + offset), 0, name);
+            }
+
+            return this;
+        },
+
+        
+        getNamesByExpression: function(expression) {
+            var nameToAliasesMap = this.maps.nameToAliases,
+                names = [],
+                name, alias, aliases, possibleName, regex, i, ln;
+
+
+            if (expression.indexOf('*') !== -1) {
+                expression = expression.replace(/\*/g, '(.*?)');
+                regex = new RegExp('^' + expression + '$');
+
+                for (name in nameToAliasesMap) {
+                    if (nameToAliasesMap.hasOwnProperty(name)) {
+                        aliases = nameToAliasesMap[name];
+
+                        if (name.search(regex) !== -1) {
+                            names.push(name);
+                        }
+                        else {
+                            for (i = 0, ln = aliases.length; i < ln; i++) {
+                                alias = aliases[i];
+
+                                if (alias.search(regex) !== -1) {
+                                    names.push(name);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+
+            } else {
+                possibleName = this.getNameByAlias(expression);
+
+                if (possibleName) {
+                    names.push(possibleName);
+                } else {
+                    possibleName = this.getNameByAlternate(expression);
+
+                    if (possibleName) {
+                        names.push(possibleName);
+                    } else {
+                        names.push(expression);
+                    }
+                }
+            }
+
+            return names;
+        }
+    };
+
+    
+    Manager.registerPostprocessor('alias', function(name, cls, data) {
+        var aliases = data.alias,
+            i, ln;
+
+        for (i = 0,ln = aliases.length; i < ln; i++) {
+            alias = aliases[i];
+
+            this.setAlias(cls, alias);
+        }
+
+    }, ['xtype', 'alias']);
+
+    
+    Manager.registerPostprocessor('singleton', function(name, cls, data, fn) {
+        fn.call(this, name, new cls(), data);
+        return false;
+    });
+
+    
+    Manager.registerPostprocessor('alternateClassName', function(name, cls, data) {
+        var alternates = data.alternateClassName,
+            i, ln, alternate;
+
+        if (!(alternates instanceof Array)) {
+            alternates = [alternates];
+        }
+
+        for (i = 0, ln = alternates.length; i < ln; i++) {
+            alternate = alternates[i];
+
+
+            this.set(alternate, cls);
+        }
+    });
+
+    Ext.apply(Ext, {
+        
+        create: alias(Manager, 'instantiate'),
+
+        
+        widget: function(name, config) {
+            
+            
+            
+            
+            
+            
+            
+            var xtype = name,
+                alias, className, T, load;
+
+            if (typeof xtype != 'string') { 
+                
+                config = name; 
+                xtype = config.xtype;
+            } else {
+                config = config || {};
+            }
+            
+            if (config.isComponent) {
+                return config;
+            }
+
+            alias = 'widget.' + xtype;
+            className = Manager.getNameByAlias(alias);
+
+            
+            if (!className) {
+                load = true;
+            }
+            
+            T = Manager.get(className);
+            if (load || !T) {
+                return Manager.instantiateByAlias(alias, config);
+            }
+            return new T(config);
+        },
+
+        
+        createByAlias: alias(Manager, 'instantiateByAlias'),
+
+        
+        define: function (className, data, createdFn) {
+            if (data.override) {
+                return Manager.createOverride.apply(Manager, arguments);
+            }
+
+            return Manager.create.apply(Manager, arguments);
+        },
+
+        
+        getClassName: alias(Manager, 'getName'),
+
+        
+        getDisplayName: function(object) {
+            if (object) {
+                if (object.displayName) {
+                    return object.displayName;
+                }
+
+                if (object.$name && object.$class) {
+                    return Ext.getClassName(object.$class) + '#' + object.$name;
+                }
+
+                if (object.$className) {
+                    return object.$className;
+                }
+            }
+
+            return 'Anonymous';
+        },
+
+        
+        getClass: alias(Manager, 'getClass'),
+
+        
+        namespace: alias(Manager, 'createNamespaces')
+    });
+
+    
+    Ext.createWidget = Ext.widget;
+
+    
+    Ext.ns = Ext.namespace;
+
+    Class.registerPreprocessor('className', function(cls, data) {
+        if (data.$className) {
+            cls.$className = data.$className;
+        }
+    }, true, 'first');
+
+    Class.registerPreprocessor('alias', function(cls, data) {
+        var prototype = cls.prototype,
+            xtypes = arrayFrom(data.xtype),
+            aliases = arrayFrom(data.alias),
+            widgetPrefix = 'widget.',
+            widgetPrefixLength = widgetPrefix.length,
+            xtypesChain = Array.prototype.slice.call(prototype.xtypesChain || []),
+            xtypesMap = Ext.merge({}, prototype.xtypesMap || {}),
+            i, ln, alias, xtype;
+
+        for (i = 0,ln = aliases.length; i < ln; i++) {
+            alias = aliases[i];
+
+
+            if (alias.substring(0, widgetPrefixLength) === widgetPrefix) {
+                xtype = alias.substring(widgetPrefixLength);
+                Ext.Array.include(xtypes, xtype);
+            }
+        }
+
+        cls.xtype = data.xtype = xtypes[0];
+        data.xtypes = xtypes;
+
+        for (i = 0,ln = xtypes.length; i < ln; i++) {
+            xtype = xtypes[i];
+
+            if (!xtypesMap[xtype]) {
+                xtypesMap[xtype] = true;
+                xtypesChain.push(xtype);
+            }
+        }
+
+        data.xtypesChain = xtypesChain;
+        data.xtypesMap = xtypesMap;
+
+        Ext.Function.interceptAfter(data, 'onClassCreated', function() {
+            var mixins = prototype.mixins,
+                key, mixin;
+
+            for (key in mixins) {
+                if (mixins.hasOwnProperty(key)) {
+                    mixin = mixins[key];
+
+                    xtypes = mixin.xtypes;
+
+                    if (xtypes) {
+                        for (i = 0,ln = xtypes.length; i < ln; i++) {
+                            xtype = xtypes[i];
+
+                            if (!xtypesMap[xtype]) {
+                                xtypesMap[xtype] = true;
+                                xtypesChain.push(xtype);
+                            }
+                        }
+                    }
+                }
+            }
+        });
+
+        for (i = 0,ln = xtypes.length; i < ln; i++) {
+            xtype = xtypes[i];
+
+
+            Ext.Array.include(aliases, widgetPrefix + xtype);
+        }
+
+        data.alias = aliases;
+
+    }, ['xtype', 'alias']);
+
+}(Ext.Class, Ext.Function.alias, Array.prototype.slice, Ext.Array.from, Ext.global));
+
+//@tag foundation,core
+
+//@require ClassManager.js
+
+//@define Ext.Loader
+
+
+
+
+Ext.Loader = new function() {
+    var Loader = this,
+        Manager = Ext.ClassManager,
+        Class = Ext.Class,
+        flexSetter = Ext.Function.flexSetter,
+        alias = Ext.Function.alias,
+        pass = Ext.Function.pass,
+        defer = Ext.Function.defer,
+        arrayErase = Ext.Array.erase,
+        dependencyProperties = ['extend', 'mixins', 'requires'],
+        isInHistory = {},
+        history = [],
+        slashDotSlashRe = /\/\.\//g,
+        dotRe = /\./g;
+
+    Ext.apply(Loader, {
+
+        
+        isInHistory: isInHistory,
+
+        
+        history: history,
+
+        
+        config: {
+            
+            enabled: false,
+
+            
+            scriptChainDelay : false,
+
+            
+            disableCaching: true,
+
+            
+            disableCachingParam: '_dc',
+
+            
+            garbageCollect : false,
+
+            
+            paths: {
+                'Ext': '.'
+            },
+
+            
+            preserveScripts : true,
+
+            
+            scriptCharset : undefined
+        },
+
+        
+        setConfig: function(name, value) {
+            if (Ext.isObject(name) && arguments.length === 1) {
+                Ext.merge(Loader.config, name);
+            }
+            else {
+                Loader.config[name] = (Ext.isObject(value)) ? Ext.merge(Loader.config[name], value) : value;
+            }
+
+            return Loader;
+        },
+
+        
+        getConfig: function(name) {
+            if (name) {
+                return Loader.config[name];
+            }
+
+            return Loader.config;
+        },
+
+        
+        setPath: flexSetter(function(name, path) {
+            Loader.config.paths[name] = path;
+
+            return Loader;
+        }),
+
+        
+        addClassPathMappings: function(paths) {
+            var name;
+
+            for(name in paths){
+                Loader.config.paths[name] = paths[name];
+            }
+            return Loader;
+        },
+
+        
+        getPath: function(className) {
+            var path = '',
+                paths = Loader.config.paths,
+                prefix = Loader.getPrefix(className);
+
+            if (prefix.length > 0) {
+                if (prefix === className) {
+                    return paths[prefix];
+                }
+
+                path = paths[prefix];
+                className = className.substring(prefix.length + 1);
+            }
+
+            if (path.length > 0) {
+                path += '/';
+            }
+
+            return path.replace(slashDotSlashRe, '/') + className.replace(dotRe, "/") + '.js';
+        },
+
+        
+        getPrefix: function(className) {
+            var paths = Loader.config.paths,
+                prefix, deepestPrefix = '';
+
+            if (paths.hasOwnProperty(className)) {
+                return className;
+            }
+
+            for (prefix in paths) {
+                if (paths.hasOwnProperty(prefix) && prefix + '.' === className.substring(0, prefix.length + 1)) {
+                    if (prefix.length > deepestPrefix.length) {
+                        deepestPrefix = prefix;
+                    }
+                }
+            }
+
+            return deepestPrefix;
+        },
+
+        
+        isAClassNameWithAKnownPrefix: function(className) {
+            var prefix = Loader.getPrefix(className);
+
+            
+            return prefix !== '' && prefix !== className;
+        },
+
+        
+        require: function(expressions, fn, scope, excludes) {
+            if (fn) {
+                fn.call(scope);
+            }
+        },
+
+        
+        syncRequire: function() {},
+
+        
+        exclude: function(excludes) {
+            return {
+                require: function(expressions, fn, scope) {
+                    return Loader.require(expressions, fn, scope, excludes);
+                },
+
+                syncRequire: function(expressions, fn, scope) {
+                    return Loader.syncRequire(expressions, fn, scope, excludes);
+                }
+            };
+        },
+
+        
+        onReady: function(fn, scope, withDomReady, options) {
+            var oldFn;
+
+            if (withDomReady !== false && Ext.onDocumentReady) {
+                oldFn = fn;
+
+                fn = function() {
+                    Ext.onDocumentReady(oldFn, scope, options);
+                };
+            }
+
+            fn.call(scope);
+        }
+    });
+
+    var queue = [],
+        isClassFileLoaded = {},
+        isFileLoaded = {},
+        classNameToFilePathMap = {},
+        scriptElements = {},
+        readyListeners = [],
+        usedClasses = [],
+        requiresMap = {};
+
+    Ext.apply(Loader, {
+        
+        documentHead: typeof document != 'undefined' && (document.head || document.getElementsByTagName('head')[0]),
+
+        
+        isLoading: false,
+
+        
+        queue: queue,
+
+        
+        isClassFileLoaded: isClassFileLoaded,
+
+        
+        isFileLoaded: isFileLoaded,
+
+        
+        readyListeners: readyListeners,
+
+        
+        optionalRequires: usedClasses,
+
+        
+        requiresMap: requiresMap,
+
+        
+        numPendingFiles: 0,
+
+        
+        numLoadedFiles: 0,
+
+        
+        hasFileLoadError: false,
+
+        
+        classNameToFilePathMap: classNameToFilePathMap,
+
+        
+        scriptsLoading: 0,
+
+        
+        syncModeEnabled: false,
+
+        scriptElements: scriptElements,
+
+        
+        refreshQueue: function() {
+            var ln = queue.length,
+                i, item, j, requires;
+
+            
+
+            if (!ln && !Loader.scriptsLoading) {
+                return Loader.triggerReady();
+            }
+
+            for (i = 0; i < ln; i++) {
+                item = queue[i];
+
+                if (item) {
+                    requires = item.requires;
+
+                    
+                    
+                    if (requires.length > Loader.numLoadedFiles) {
+                        continue;
+                    }
+
+                    
+                    for (j = 0; j < requires.length; ) {
+                        if (Manager.isCreated(requires[j])) {
+                            
+                            arrayErase(requires, j, 1);
+                        }
+                        else {
+                            j++;
+                        }
+                    }
+
+                    
+                    if (item.requires.length === 0) {
+                        arrayErase(queue, i, 1);
+                        item.callback.call(item.scope);
+                        Loader.refreshQueue();
+                        break;
+                    }
+                }
+            }
+
+            return Loader;
+        },
+
+        
+        injectScriptElement: function(url, onLoad, onError, scope, charset) {
+            var script = document.createElement('script'),
+                dispatched = false,
+                config = Loader.config,
+                onLoadFn = function() {
+
+                    if(!dispatched) {
+                        dispatched = true;
+                        script.onload = script.onreadystatechange = script.onerror = null;
+                        if (typeof config.scriptChainDelay == 'number') {
+                            
+                            defer(onLoad, config.scriptChainDelay, scope);
+                        } else {
+                            onLoad.call(scope);
+                        }
+                        Loader.cleanupScriptElement(script, config.preserveScripts === false, config.garbageCollect);
+                    }
+
+                },
+                onErrorFn = function(arg) {
+                    defer(onError, 1, scope);   
+                    Loader.cleanupScriptElement(script, config.preserveScripts === false, config.garbageCollect);
+                };
+
+            script.type = 'text/javascript';
+            script.onerror = onErrorFn;
+            charset = charset || config.scriptCharset;
+            if (charset) {
+                script.charset = charset;
+            }
+
+            
+            if ('addEventListener' in script ) {
+                script.onload = onLoadFn;
+            } else if ('readyState' in script) {   
+                script.onreadystatechange = function() {
+                    if ( this.readyState == 'loaded' || this.readyState == 'complete' ) {
+                        onLoadFn();
+                    }
+                };
+            } else {
+                 script.onload = onLoadFn;
+            }
+
+            script.src = url;
+            (Loader.documentHead || document.getElementsByTagName('head')[0]).appendChild(script);
+
+            return script;
+        },
+
+        
+        removeScriptElement: function(url) {
+            if (scriptElements[url]) {
+                Loader.cleanupScriptElement(scriptElements[url], true, !!Loader.getConfig('garbageCollect'));
+                delete scriptElements[url];
+            }
+
+            return Loader;
+        },
+
+        
+        cleanupScriptElement: function(script, remove, collect) {
+            var prop;
+            script.onload = script.onreadystatechange = script.onerror = null;
+            if (remove) {
+                Ext.removeNode(script);       
+                if (collect) {
+                    for (prop in script) {
+                        try {
+                            script[prop] = null;
+                            delete script[prop];      
+                        } catch (cleanEx) {
+                            
+                        }
+                    }
+                }
+            }
+
+            return Loader;
+        },
+
+        
+        loadScript: function (options) {
+            var config = Loader.getConfig(),
+                isString = typeof options == 'string',
+                url = isString ? options : options.url,
+                onError = !isString && options.onError,
+                onLoad = !isString && options.onLoad,
+                scope = !isString && options.scope,
+                onScriptError = function() {
+                    Loader.numPendingFiles--;
+                    Loader.scriptsLoading--;
+
+                    if (onError) {
+                        onError.call(scope, "Failed loading '" + url + "', please verify that the file exists");
+                    }
+
+                    if (Loader.numPendingFiles + Loader.scriptsLoading === 0) {
+                        Loader.refreshQueue();
+                    }
+                },
+                onScriptLoad = function () {
+                    Loader.numPendingFiles--;
+                    Loader.scriptsLoading--;
+
+                    if (onLoad) {
+                        onLoad.call(scope);
+                    }
+
+                    if (Loader.numPendingFiles + Loader.scriptsLoading === 0) {
+                        Loader.refreshQueue();
+                    }
+                },
+                src;
+
+            Loader.isLoading = true;
+            Loader.numPendingFiles++;
+            Loader.scriptsLoading++;
+
+            src = config.disableCaching ?
+                (url + '?' + config.disableCachingParam + '=' + Ext.Date.now()) : url;
+
+            scriptElements[url] = Loader.injectScriptElement(src, onScriptLoad, onScriptError);
+        },
+
+        
+        loadScriptFile: function(url, onLoad, onError, scope, synchronous) {
+            if (isFileLoaded[url]) {
+                return Loader;
+            }
+
+            var config = Loader.getConfig(),
+                noCacheUrl = url + (config.disableCaching ? ('?' + config.disableCachingParam + '=' + Ext.Date.now()) : ''),
+                isCrossOriginRestricted = false,
+                xhr, status, onScriptError,
+                debugSourceURL = "";
+
+            scope = scope || Loader;
+
+            Loader.isLoading = true;
+
+            if (!synchronous) {
+                onScriptError = function() {
+                };
+
+                scriptElements[url] = Loader.injectScriptElement(noCacheUrl, onLoad, onScriptError, scope);
+            } else {
+                if (typeof XMLHttpRequest != 'undefined') {
+                    xhr = new XMLHttpRequest();
+                } else {
+                    xhr = new ActiveXObject('Microsoft.XMLHTTP');
+                }
+
+                try {
+                    xhr.open('GET', noCacheUrl, false);
+                    xhr.send(null);
+                } catch (e) {
+                    isCrossOriginRestricted = true;
+                }
+
+                status = (xhr.status === 1223) ? 204 :
+                    (xhr.status === 0 && (self.location || {}).protocol == 'file:') ? 200 : xhr.status;
+
+                isCrossOriginRestricted = isCrossOriginRestricted || (status === 0);
+
+                if (isCrossOriginRestricted
+                ) {
+                }
+                else if ((status >= 200 && status < 300) || (status === 304)
+                ) {
+                    
+                    
+                    if (!Ext.isIE) {
+                        debugSourceURL = "\n//@ sourceURL=" + url;
+                    }
+
+                    Ext.globalEval(xhr.responseText + debugSourceURL);
+
+                    onLoad.call(scope);
+                }
+                else {
+                }
+
+                
+                xhr = null;
+            }
+        },
+
+        
+        syncRequire: function() {
+            var syncModeEnabled = Loader.syncModeEnabled;
+
+            if (!syncModeEnabled) {
+                Loader.syncModeEnabled = true;
+            }
+
+            Loader.require.apply(Loader, arguments);
+
+            if (!syncModeEnabled) {
+                Loader.syncModeEnabled = false;
+            }
+
+            Loader.refreshQueue();
+        },
+
+        
+        require: function(expressions, fn, scope, excludes) {
+            var excluded = {},
+                included = {},
+                excludedClassNames = [],
+                possibleClassNames = [],
+                classNames = [],
+                references = [],
+                callback,
+                syncModeEnabled,
+                filePath, expression, exclude, className,
+                possibleClassName, i, j, ln, subLn;
+
+            if (excludes) {
+                
+                excludes = (typeof excludes === 'string') ? [ excludes ] : excludes;
+
+                for (i = 0,ln = excludes.length; i < ln; i++) {
+                    exclude = excludes[i];
+
+                    if (typeof exclude == 'string' && exclude.length > 0) {
+                        excludedClassNames = Manager.getNamesByExpression(exclude);
+
+                        for (j = 0,subLn = excludedClassNames.length; j < subLn; j++) {
+                            excluded[excludedClassNames[j]] = true;
+                        }
+                    }
+                }
+            }
+
+            
+            expressions = (typeof expressions === 'string') ? [ expressions ] : (expressions ? expressions : []);
+
+            if (fn) {
+                if (fn.length > 0) {
+                    callback = function() {
+                        var classes = [],
+                            i, ln;
+
+                        for (i = 0,ln = references.length; i < ln; i++) {
+                            classes.push(Manager.get(references[i]));
+                        }
+
+                        return fn.apply(this, classes);
+                    };
+                }
+                else {
+                    callback = fn;
+                }
+            }
+            else {
+                callback = Ext.emptyFn;
+            }
+
+            scope = scope || Ext.global;
+
+            for (i = 0,ln = expressions.length; i < ln; i++) {
+                expression = expressions[i];
+
+                if (typeof expression == 'string' && expression.length > 0) {
+                    possibleClassNames = Manager.getNamesByExpression(expression);
+                    subLn = possibleClassNames.length;
+
+                    for (j = 0; j < subLn; j++) {
+                        possibleClassName = possibleClassNames[j];
+
+                        if (excluded[possibleClassName] !== true) {
+                            references.push(possibleClassName);
+
+                            if (!Manager.isCreated(possibleClassName) && !included[possibleClassName]) {
+                                included[possibleClassName] = true;
+                                classNames.push(possibleClassName);
+                            }
+                        }
+                    }
+                }
+            }
+
+            
+            
+            if (classNames.length > 0) {
+                if (!Loader.config.enabled) {
+                    throw new Error("Ext.Loader is not enabled, so dependencies cannot be resolved dynamically. " +
+                             "Missing required class" + ((classNames.length > 1) ? "es" : "") + ": " + classNames.join(', '));
+                }
+            }
+            else {
+                callback.call(scope);
+                return Loader;
+            }
+
+            syncModeEnabled = Loader.syncModeEnabled;
+
+            if (!syncModeEnabled) {
+                queue.push({
+                    requires: classNames.slice(), 
+                                                  
+                    callback: callback,
+                    scope: scope
+                });
+            }
+
+            ln = classNames.length;
+
+            for (i = 0; i < ln; i++) {
+                className = classNames[i];
+
+                filePath = Loader.getPath(className);
+
+                
+                
+                
+                if (syncModeEnabled && isClassFileLoaded.hasOwnProperty(className)) {
+                    Loader.numPendingFiles--;
+                    Loader.removeScriptElement(filePath);
+                    delete isClassFileLoaded[className];
+                }
+
+                if (!isClassFileLoaded.hasOwnProperty(className)) {
+                    isClassFileLoaded[className] = false;
+
+                    classNameToFilePathMap[className] = filePath;
+
+                    Loader.numPendingFiles++;
+                    Loader.loadScriptFile(
+                        filePath,
+                        pass(Loader.onFileLoaded, [className, filePath], Loader),
+                        pass(Loader.onFileLoadError, [className, filePath], Loader),
+                        Loader,
+                        syncModeEnabled
+                    );
+                }
+            }
+
+            if (syncModeEnabled) {
+                callback.call(scope);
+
+                if (ln === 1) {
+                    return Manager.get(className);
+                }
+            }
+
+            return Loader;
+        },
+
+        
+        onFileLoaded: function(className, filePath) {
+            Loader.numLoadedFiles++;
+
+            isClassFileLoaded[className] = true;
+            isFileLoaded[filePath] = true;
+
+            Loader.numPendingFiles--;
+
+            if (Loader.numPendingFiles === 0) {
+                Loader.refreshQueue();
+            }
+
+        },
+
+        
+        onFileLoadError: function(className, filePath, errorMessage, isSynchronous) {
+            Loader.numPendingFiles--;
+            Loader.hasFileLoadError = true;
+
+        },
+
+        
+        addUsedClasses: function (classes) {
+            var cls, i, ln;
+
+            if (classes) {
+                classes = (typeof classes == 'string') ? [classes] : classes;
+                for (i = 0, ln = classes.length; i < ln; i++) {
+                    cls = classes[i];
+                    if (typeof cls == 'string' && !Ext.Array.contains(usedClasses, cls)) {
+                        usedClasses.push(cls);
+                    }
+                }
+            }
+
+            return Loader;
+        },
+
+        
+        triggerReady: function() {
+            var listener,
+                i, refClasses = usedClasses;
+
+            if (Loader.isLoading) {
+                Loader.isLoading = false;
+
+                if (refClasses.length !== 0) {
+                    
+                    refClasses = refClasses.slice();
+                    usedClasses.length = 0;
+                    
+                    
+                    Loader.require(refClasses, Loader.triggerReady, Loader);
+                    return Loader;
+                }
+            }
+
+            
+            
+            
+            while (readyListeners.length && !Loader.isLoading) {
+                
+                
+                listener = readyListeners.shift();
+                listener.fn.call(listener.scope);
+            }
+
+            return Loader;
+        },
+
+        
+        onReady: function(fn, scope, withDomReady, options) {
+            var oldFn;
+
+            if (withDomReady !== false && Ext.onDocumentReady) {
+                oldFn = fn;
+
+                fn = function() {
+                    Ext.onDocumentReady(oldFn, scope, options);
+                };
+            }
+
+            if (!Loader.isLoading) {
+                fn.call(scope);
+            }
+            else {
+                readyListeners.push({
+                    fn: fn,
+                    scope: scope
+                });
+            }
+        },
+
+        
+        historyPush: function(className) {
+            if (className && isClassFileLoaded.hasOwnProperty(className) && !isInHistory[className]) {
+                isInHistory[className] = true;
+                history.push(className);
+            }
+            return Loader;
+        }
+    });
+
+    
+    Ext.disableCacheBuster = function (disable, path) {
+        var date = new Date();
+        date.setTime(date.getTime() + (disable ? 10*365 : -1) * 24*60*60*1000);
+        date = date.toGMTString();
+        document.cookie = 'ext-cache=1; expires=' + date + '; path='+(path || '/');
+    };
+
+
+    
+    Ext.require = alias(Loader, 'require');
+
+    
+    Ext.syncRequire = alias(Loader, 'syncRequire');
+
+    
+    Ext.exclude = alias(Loader, 'exclude');
+
+    
+    Ext.onReady = function(fn, scope, options) {
+        Loader.onReady(fn, scope, true, options);
+    };
+
+    
+    Class.registerPreprocessor('loader', function(cls, data, hooks, continueFn) {
+        var me = this,
+            dependencies = [],
+            dependency,
+            className = Manager.getName(cls),
+            i, j, ln, subLn, value, propertyName, propertyValue,
+            requiredMap, requiredDep;
+
+        
+
+        for (i = 0,ln = dependencyProperties.length; i < ln; i++) {
+            propertyName = dependencyProperties[i];
+
+            if (data.hasOwnProperty(propertyName)) {
+                propertyValue = data[propertyName];
+
+                if (typeof propertyValue == 'string') {
+                    dependencies.push(propertyValue);
+                }
+                else if (propertyValue instanceof Array) {
+                    for (j = 0, subLn = propertyValue.length; j < subLn; j++) {
+                        value = propertyValue[j];
+
+                        if (typeof value == 'string') {
+                            dependencies.push(value);
+                        }
+                    }
+                }
+                else if (typeof propertyValue != 'function') {
+                    for (j in propertyValue) {
+                        if (propertyValue.hasOwnProperty(j)) {
+                            value = propertyValue[j];
+
+                            if (typeof value == 'string') {
+                                dependencies.push(value);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if (dependencies.length === 0) {
+            return;
+        }
+
+
+        Loader.require(dependencies, function() {
+            for (i = 0,ln = dependencyProperties.length; i < ln; i++) {
+                propertyName = dependencyProperties[i];
+
+                if (data.hasOwnProperty(propertyName)) {
+                    propertyValue = data[propertyName];
+
+                    if (typeof propertyValue == 'string') {
+                        data[propertyName] = Manager.get(propertyValue);
+                    }
+                    else if (propertyValue instanceof Array) {
+                        for (j = 0, subLn = propertyValue.length; j < subLn; j++) {
+                            value = propertyValue[j];
+
+                            if (typeof value == 'string') {
+                                data[propertyName][j] = Manager.get(value);
+                            }
+                        }
+                    }
+                    else if (typeof propertyValue != 'function') {
+                        for (var k in propertyValue) {
+                            if (propertyValue.hasOwnProperty(k)) {
+                                value = propertyValue[k];
+
+                                if (typeof value == 'string') {
+                                    data[propertyName][k] = Manager.get(value);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            continueFn.call(me, cls, data, hooks);
+        });
+
+        return false;
+    }, true, 'after', 'className');
+
+    
+    Manager.registerPostprocessor('uses', function(name, cls, data) {
+        var uses = data.uses;
+        if (uses) {
+            Loader.addUsedClasses(uses);
+        }
+    });
+
+    Manager.onCreated(Loader.historyPush);
+};
+
+
+
+if (Ext._classPathMetadata) {
+    Ext.Loader.addClassPathMappings(Ext._classPathMetadata);
+    Ext._classPathMetadata = null;
+}
+
+
+(function() {
+    var scripts = document.getElementsByTagName('script'),
+        currentScript = scripts[scripts.length - 1],
+        src = currentScript.src,
+        path = src.substring(0, src.lastIndexOf('/') + 1),
+        Loader = Ext.Loader;
+
+
+    Loader.setConfig({
+        enabled: true,
+        disableCaching: true,
+        paths: {
+            'Ext': path + 'src'
+        }
+    });
+})();
+
+
+
+Ext._endTime = new Date().getTime();
+if (Ext._beforereadyhandler){
+    Ext._beforereadyhandler();
+}
+
+//@tag foundation,core
+
+//@require ../class/Loader.js
+
+
+
+Ext.Error = Ext.extend(Error, {
+    statics: {
+        
+        ignore: false,
+
+        
+        
+
+        
+        raise: function(err){
+            err = err || {};
+            if (Ext.isString(err)) {
+                err = { msg: err };
+            }
+
+            var method = this.raise.caller,
+                msg;
+
+            if (method) {
+                if (method.$name) {
+                    err.sourceMethod = method.$name;
+                }
+                if (method.$owner) {
+                    err.sourceClass = method.$owner.$className;
+                }
+            }
+
+            if (Ext.Error.handle(err) !== true) {
+                msg = Ext.Error.prototype.toString.call(err);
+
+                Ext.log({
+                    msg: msg,
+                    level: 'error',
+                    dump: err,
+                    stack: true
+                });
+
+                throw new Ext.Error(err);
+            }
+        },
+
+        
+        handle: function(){
+            return Ext.Error.ignore;
+        }
+    },
+
+    
+    name: 'Ext.Error',
+
+    
+    constructor: function(config){
+        if (Ext.isString(config)) {
+            config = { msg: config };
+        }
+
+        var me = this;
+
+        Ext.apply(me, config);
+
+        me.message = me.message || me.msg; 
+        
+    },
+
+    
+    toString: function(){
+        var me = this,
+            className = me.sourceClass ? me.sourceClass : '',
+            methodName = me.sourceMethod ? '.' + me.sourceMethod + '(): ' : '',
+            msg = me.msg || '(No description provided)';
+
+        return className + methodName + msg;
+    }
+});
+
+
+Ext.deprecated = function (suggestion) {
+    return Ext.emptyFn;
+};
+
+
+
+//@tag extras,core
+
+//@require ../lang/Error.js
+
+
+
+Ext.JSON = (new(function() {
+    var me = this,
+    encodingFunction,
+    decodingFunction,
+    useNative = null,
+    useHasOwn = !! {}.hasOwnProperty,
+    isNative = function() {
+        if (useNative === null) {
+            useNative = Ext.USE_NATIVE_JSON && window.JSON && JSON.toString() == '[object JSON]';
+        }
+        return useNative;
+    },
+    pad = function(n) {
+        return n < 10 ? "0" + n : n;
+    },
+    doDecode = function(json) {
+        return eval("(" + json + ')');
+    },
+    doEncode = function(o, newline) {
+        
+        if (o === null || o === undefined) {
+            return "null";
+        } else if (Ext.isDate(o)) {
+            return Ext.JSON.encodeDate(o);
+        } else if (Ext.isString(o)) {
+            return Ext.JSON.encodeString(o);
+        } else if (typeof o == "number") {
+            
+            return isFinite(o) ? String(o) : "null";
+        } else if (Ext.isBoolean(o)) {
+            return String(o);
+        }
+        
+        
+        else if (o.toJSON) {
+            return o.toJSON();
+        } else if (Ext.isArray(o)) {
+            return encodeArray(o, newline);
+        } else if (Ext.isObject(o)) {
+            return encodeObject(o, newline);
+        } else if (typeof o === "function") {
+            return "null";
+        }
+        return 'undefined';
+    },
+    m = {
+        "\b": '\\b',
+        "\t": '\\t',
+        "\n": '\\n',
+        "\f": '\\f',
+        "\r": '\\r',
+        '"': '\\"',
+        "\\": '\\\\',
+        '\x0b': '\\u000b' 
+    },
+    charToReplace = /[\\\"\x00-\x1f\x7f-\uffff]/g,
+    encodeString = function(s) {
+        return '"' + s.replace(charToReplace, function(a) {
+            var c = m[a];
+            return typeof c === 'string' ? c : '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+        }) + '"';
+    },
+
+
+    encodeArray = function(o, newline) {
+
+        var a = ["[", ""], 
+            len = o.length,
+            i;
+        for (i = 0; i < len; i += 1) {
+            a.push(Ext.JSON.encodeValue(o[i]), ',');
+        }
+        
+        a[a.length - 1] = ']';
+        return a.join("");
+    },
+
+    encodeObject = function(o, newline) {
+
+        var a = ["{", ""], 
+            i;
+        for (i in o) {
+            if (!useHasOwn || o.hasOwnProperty(i)) {
+                a.push(Ext.JSON.encodeValue(i), ":", Ext.JSON.encodeValue(o[i]), ',');
+            }
+        }
+        
+        a[a.length - 1] = '}';
+        return a.join("");
+    };
+    
+    
+    me.encodeString = encodeString;
+
+    
+    me.encodeValue = doEncode;
+
+    
+    me.encodeDate = function(o) {
+        return '"' + o.getFullYear() + "-"
+        + pad(o.getMonth() + 1) + "-"
+        + pad(o.getDate()) + "T"
+        + pad(o.getHours()) + ":"
+        + pad(o.getMinutes()) + ":"
+        + pad(o.getSeconds()) + '"';
+    };
+
+    
+    me.encode = function(o) {
+        if (!encodingFunction) {
+            
+            encodingFunction = isNative() ? JSON.stringify : me.encodeValue;
+        }
+        return encodingFunction(o);
+    };
+
+    
+    me.decode = function(json, safe) {
+        if (!decodingFunction) {
+            
+            decodingFunction = isNative() ? JSON.parse : doDecode;
+        }
+        try {
+            return decodingFunction(json);
+        } catch (e) {
+            if (safe === true) {
+                return null;
+            }
+            Ext.Error.raise({
+                sourceClass: "Ext.JSON",
+                sourceMethod: "decode",
+                msg: "You're trying to decode an invalid JSON String: " + json
+            });
+        }
+    };
+})());
+
+Ext.encode = Ext.JSON.encode;
+
+Ext.decode = Ext.JSON.decode;
+
+//@tag extras,core
+
+//@require misc/JSON.js
+
+
+
+Ext.apply(Ext, {
+    userAgent: navigator.userAgent.toLowerCase(),
+    cache: {},
+    idSeed: 1000,
+    windowId: 'ext-window',
+    documentId: 'ext-document',
+
+    
+    isReady: false,
+
+    
+    enableGarbageCollector: true,
+
+    
+    enableListenerCollection: true,
+
+    addCacheEntry: function(id, el, dom) {
+        dom = dom || el.dom;
+
+
+        var key = id || (el && el.id) || dom.id,
+            entry = Ext.cache[key] || (Ext.cache[key] = {
+                data: {},
+                events: {},
+
+                dom: dom,
+
+                
+                skipGarbageCollection: !!(dom.getElementById || dom.navigator)
+            });
+
+        if (el) {
+            el.$cache = entry;
+            
+            
+            entry.el = el;
+        }
+
+        return entry;
+    },
+    
+    updateCacheEntry: function(cacheItem, dom){
+        cacheItem.dom = dom;
+        if (cacheItem.el) {
+            cacheItem.el.dom = dom;
+        }
+        return cacheItem;
+    },
+
+    
+    id: function(el, prefix) {
+        var me = this,
+            sandboxPrefix = '';
+        el = Ext.getDom(el, true) || {};
+        if (el === document) {
+            el.id = me.documentId;
+        }
+        else if (el === window) {
+            el.id = me.windowId;
+        }
+        if (!el.id) {
+            if (me.isSandboxed) {
+                sandboxPrefix = Ext.sandboxName.toLowerCase() + '-';
+            }
+            el.id = sandboxPrefix + (prefix || "ext-gen") + (++Ext.idSeed);
+        }
+        return el.id;
+    },
+
+    escapeId: (function(){
+        var validIdRe = /^[a-zA-Z_][a-zA-Z0-9_\-]*$/i,
+            escapeRx = /([\W]{1})/g,
+            leadingNumRx = /^(\d)/g,
+            escapeFn = function(match, capture){
+                return "\\" + capture;
+            },
+            numEscapeFn = function(match, capture){
+                return '\\00' + capture.charCodeAt(0).toString(16) + ' ';
+            };
+
+        return function(id) {
+            return validIdRe.test(id)
+                ? id
+                
+                
+                : id.replace(escapeRx, escapeFn)
+                    .replace(leadingNumRx, numEscapeFn);
+        };
+    }()),
+
+    
+    getBody: (function() {
+        var body;
+        return function() {
+            return body || (body = Ext.get(document.body));
+        };
+    }()),
+
+    
+    getHead: (function() {
+        var head;
+        return function() {
+            return head || (head = Ext.get(document.getElementsByTagName("head")[0]));
+        };
+    }()),
+
+    
+    getDoc: (function() {
+        var doc;
+        return function() {
+            return doc || (doc = Ext.get(document));
+        };
+    }()),
+
+    
+    getCmp: function(id) {
+        return Ext.ComponentManager.get(id);
+    },
+
+    
+    getOrientation: function() {
+        return window.innerHeight > window.innerWidth ? 'portrait' : 'landscape';
+    },
+
+    
+    destroy: function() {
+        var ln = arguments.length,
+        i, arg;
+
+        for (i = 0; i < ln; i++) {
+            arg = arguments[i];
+            if (arg) {
+                if (Ext.isArray(arg)) {
+                    this.destroy.apply(this, arg);
+                }
+                else if (Ext.isFunction(arg.destroy)) {
+                    arg.destroy();
+                }
+                else if (arg.dom) {
+                    arg.remove();
+                }
+            }
+        }
+    },
+
+    
+    callback: function(callback, scope, args, delay){
+        if(Ext.isFunction(callback)){
+            args = args || [];
+            scope = scope || window;
+            if (delay) {
+                Ext.defer(callback, delay, scope, args);
+            } else {
+                callback.apply(scope, args);
+            }
+        }
+    },
+
+    
+    htmlEncode : function(value) {
+        return Ext.String.htmlEncode(value);
+    },
+
+    
+    htmlDecode : function(value) {
+         return Ext.String.htmlDecode(value);
+    },
+
+    
+    urlAppend : function(url, s) {
+        return Ext.String.urlAppend(url, s);
+    }
+});
+
+
+Ext.ns = Ext.namespace;
+
+
+window.undefined = window.undefined;
+
+
+(function(){
+
+    var check = function(regex){
+            return regex.test(Ext.userAgent);
+        },
+        isStrict = document.compatMode == "CSS1Compat",
+        version = function (is, regex) {
+            var m;
+            return (is && (m = regex.exec(Ext.userAgent))) ? parseFloat(m[1]) : 0;
+        },
+        docMode = document.documentMode,
+        isOpera = check(/opera/),
+        isOpera10_5 = isOpera && check(/version\/10\.5/),
+        isChrome = check(/\bchrome\b/),
+        isWebKit = check(/webkit/),
+        isSafari = !isChrome && check(/safari/),
+        isSafari2 = isSafari && check(/applewebkit\/4/), 
+        isSafari3 = isSafari && check(/version\/3/),
+        isSafari4 = isSafari && check(/version\/4/),
+        isSafari5_0 = isSafari && check(/version\/5\.0/),
+        isSafari5 = isSafari && check(/version\/5/),
+        isIE = !isOpera && check(/msie/),
+        isIE7 = isIE && ((check(/msie 7/) && docMode != 8 && docMode != 9) || docMode == 7),
+        isIE8 = isIE && ((check(/msie 8/) && docMode != 7 && docMode != 9) || docMode == 8),
+        isIE9 = isIE && ((check(/msie 9/) && docMode != 7 && docMode != 8) || docMode == 9),
+        isIE6 = isIE && check(/msie 6/),
+        isGecko = !isWebKit && check(/gecko/),
+        isGecko3 = isGecko && check(/rv:1\.9/),
+        isGecko4 = isGecko && check(/rv:2\.0/),
+        isGecko5 = isGecko && check(/rv:5\./),
+        isGecko10 = isGecko && check(/rv:10\./),
+        isFF3_0 = isGecko3 && check(/rv:1\.9\.0/),
+        isFF3_5 = isGecko3 && check(/rv:1\.9\.1/),
+        isFF3_6 = isGecko3 && check(/rv:1\.9\.2/),
+        isWindows = check(/windows|win32/),
+        isMac = check(/macintosh|mac os x/),
+        isLinux = check(/linux/),
+        scrollbarSize = null,
+        chromeVersion = version(true, /\bchrome\/(\d+\.\d+)/),
+        firefoxVersion = version(true, /\bfirefox\/(\d+\.\d+)/),
+        ieVersion = version(isIE, /msie (\d+\.\d+)/),
+        operaVersion = version(isOpera, /version\/(\d+\.\d+)/),
+        safariVersion = version(isSafari, /version\/(\d+\.\d+)/),
+        webKitVersion = version(isWebKit, /webkit\/(\d+\.\d+)/),
+        isSecure = /^https/i.test(window.location.protocol),
+        nullLog;
+
+    
+    try {
+        document.execCommand("BackgroundImageCache", false, true);
+    } catch(e) {}
+
+
+
+    nullLog = function () {};
+    nullLog.info = nullLog.warn = nullLog.error = Ext.emptyFn;
+
+    Ext.setVersion('extjs', '4.1.1.1');
+    Ext.apply(Ext, {
+        
+        SSL_SECURE_URL : isSecure && isIE ? 'javascript:\'\'' : 'about:blank',
+
+        
+
+        
+        scopeResetCSS : Ext.buildSettings.scopeResetCSS,
+        
+        
+        resetCls: Ext.buildSettings.baseCSSPrefix + 'reset',
+
+        
+        enableNestedListenerRemoval : false,
+
+        
+        USE_NATIVE_JSON : false,
+
+        
+        getDom : function(el, strict) {
+            if (!el || !document) {
+                return null;
+            }
+            if (el.dom) {
+                return el.dom;
+            } else {
+                if (typeof el == 'string') {
+                    var e = Ext.getElementById(el);
+                    
+                    
+                    if (e && isIE && strict) {
+                        if (el == e.getAttribute('id')) {
+                            return e;
+                        } else {
+                            return null;
+                        }
+                    }
+                    return e;
+                } else {
+                    return el;
+                }
+            }
+        },
+
+        
+        removeNode : isIE6 || isIE7 || isIE8
+            ? (function() {
+                var d;
+                return function(n){
+                    if(n && n.tagName.toUpperCase() != 'BODY'){
+                        (Ext.enableNestedListenerRemoval) ? Ext.EventManager.purgeElement(n) : Ext.EventManager.removeAll(n);
+
+                        var cache = Ext.cache,
+                            id = n.id;
+
+                        if (cache[id]) {
+                            delete cache[id].dom;
+                            delete cache[id];
+                        }
+
+                        if (isIE8 && n.parentNode) {
+                            n.parentNode.removeChild(n);
+                        }
+                        d = d || document.createElement('div');
+                        d.appendChild(n);
+                        d.innerHTML = '';
+                    }
+                };
+            }())
+            : function(n) {
+                if (n && n.parentNode && n.tagName.toUpperCase() != 'BODY') {
+                    (Ext.enableNestedListenerRemoval) ? Ext.EventManager.purgeElement(n) : Ext.EventManager.removeAll(n);
+
+                    var cache = Ext.cache,
+                        id = n.id;
+
+                    if (cache[id]) {
+                        delete cache[id].dom;
+                        delete cache[id];
+                    }
+
+                    n.parentNode.removeChild(n);
+                }
+            },
+
+        isStrict: isStrict,
+
+        isIEQuirks: isIE && !isStrict,
+
+        
+        isOpera : isOpera,
+
+        
+        isOpera10_5 : isOpera10_5,
+
+        
+        isWebKit : isWebKit,
+
+        
+        isChrome : isChrome,
+
+        
+        isSafari : isSafari,
+
+        
+        isSafari3 : isSafari3,
+
+        
+        isSafari4 : isSafari4,
+
+        
+        isSafari5 : isSafari5,
+
+        
+        isSafari5_0 : isSafari5_0,
+
+
+        
+        isSafari2 : isSafari2,
+
+        
+        isIE : isIE,
+
+        
+        isIE6 : isIE6,
+
+        
+        isIE7 : isIE7,
+
+        
+        isIE8 : isIE8,
+
+        
+        isIE9 : isIE9,
+
+        
+        isGecko : isGecko,
+
+        
+        isGecko3 : isGecko3,
+
+        
+        isGecko4 : isGecko4,
+
+        
+        isGecko5 : isGecko5,
+
+        
+        isGecko10 : isGecko10,
+
+        
+        isFF3_0 : isFF3_0,
+
+        
+        isFF3_5 : isFF3_5,
+
+        
+        isFF3_6 : isFF3_6,
+
+        
+        isFF4 : 4 <= firefoxVersion && firefoxVersion < 5,
+
+        
+        isFF5 : 5 <= firefoxVersion && firefoxVersion < 6,
+
+        
+        isFF10 : 10 <= firefoxVersion && firefoxVersion < 11,
+
+        
+        isLinux : isLinux,
+
+        
+        isWindows : isWindows,
+
+        
+        isMac : isMac,
+
+        
+        chromeVersion: chromeVersion,
+
+        
+        firefoxVersion: firefoxVersion,
+
+        
+        ieVersion: ieVersion,
+
+        
+        operaVersion: operaVersion,
+
+        
+        safariVersion: safariVersion,
+
+        
+        webKitVersion: webKitVersion,
+
+        
+        isSecure: isSecure,
+        
+        
+        BLANK_IMAGE_URL : (isIE6 || isIE7) ? '/' + '/www.sencha.com/s.gif' : 'data:image/gif;base64,R0lGODlhAQABAID/AMDAwAAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==',
+
+        
+        value : function(v, defaultValue, allowBlank){
+            return Ext.isEmpty(v, allowBlank) ? defaultValue : v;
+        },
+
+        
+        escapeRe : function(s) {
+            return s.replace(/([-.*+?\^${}()|\[\]\/\\])/g, "\\$1");
+        },
+
+        
+        addBehaviors : function(o){
+            if(!Ext.isReady){
+                Ext.onReady(function(){
+                    Ext.addBehaviors(o);
+                });
+            } else {
+                var cache = {}, 
+                    parts,
+                    b,
+                    s;
+                for (b in o) {
+                    if ((parts = b.split('@'))[1]) { 
+                        s = parts[0];
+                        if(!cache[s]){
+                            cache[s] = Ext.select(s);
+                        }
+                        cache[s].on(parts[1], o[b]);
+                    }
+                }
+                cache = null;
+            }
+        },
+
+        
+        getScrollbarSize: function (force) {
+            if (!Ext.isReady) {
+                return {};
+            }
+
+            if (force || !scrollbarSize) {
+                var db = document.body,
+                    div = document.createElement('div');
+
+                div.style.width = div.style.height = '100px';
+                div.style.overflow = 'scroll';
+                div.style.position = 'absolute';
+
+                db.appendChild(div); 
+
+                
+                scrollbarSize = {
+                    width: div.offsetWidth - div.clientWidth,
+                    height: div.offsetHeight - div.clientHeight
+                };
+
+                db.removeChild(div);
+            }
+
+            return scrollbarSize;
+        },
+
+        
+        getScrollBarWidth: function(force){
+            var size = Ext.getScrollbarSize(force);
+            return size.width + 2; 
+        },
+
+        
+        copyTo : function(dest, source, names, usePrototypeKeys){
+            if(typeof names == 'string'){
+                names = names.split(/[,;\s]/);
+            }
+
+            var n,
+                nLen = names.length,
+                name;
+
+            for(n = 0; n < nLen; n++) {
+                name = names[n];
+
+                if(usePrototypeKeys || source.hasOwnProperty(name)){
+                    dest[name] = source[name];
+                }
+            }
+
+            return dest;
+        },
+
+        
+        destroyMembers : function(o){
+            for (var i = 1, a = arguments, len = a.length; i < len; i++) {
+                Ext.destroy(o[a[i]]);
+                delete o[a[i]];
+            }
+        },
+
+        
+        log :
+            nullLog,
+
+        
+        partition : function(arr, truth){
+            var ret = [[],[]],
+                a, v,
+                aLen = arr.length;
+
+            for (a = 0; a < aLen; a++) {
+                v = arr[a];
+                ret[ (truth && truth(v, a, arr)) || (!truth && v) ? 0 : 1].push(v);
+            }
+
+            return ret;
+        },
+
+        
+        invoke : function(arr, methodName){
+            var ret  = [],
+                args = Array.prototype.slice.call(arguments, 2),
+                a, v,
+                aLen = arr.length;
+
+            for (a = 0; a < aLen; a++) {
+                v = arr[a];
+
+                if (v && typeof v[methodName] == 'function') {
+                    ret.push(v[methodName].apply(v, args));
+                } else {
+                    ret.push(undefined);
+                }
+            }
+
+            return ret;
+        },
+
+        
+        zip : function(){
+            var parts = Ext.partition(arguments, function( val ){ return typeof val != 'function'; }),
+                arrs = parts[0],
+                fn = parts[1][0],
+                len = Ext.max(Ext.pluck(arrs, "length")),
+                ret = [],
+                i,
+                j,
+                aLen;
+
+            for (i = 0; i < len; i++) {
+                ret[i] = [];
+                if(fn){
+                    ret[i] = fn.apply(fn, Ext.pluck(arrs, i));
+                }else{
+                    for (j = 0, aLen = arrs.length; j < aLen; j++){
+                        ret[i].push( arrs[j][i] );
+                    }
+                }
+            }
+            return ret;
+        },
+
+        
+        toSentence: function(items, connector) {
+            var length = items.length,
+                head,
+                tail;
+
+            if (length <= 1) {
+                return items[0];
+            } else {
+                head = items.slice(0, length - 1);
+                tail = items[length - 1];
+
+                return Ext.util.Format.format("{0} {1} {2}", head.join(", "), connector || 'and', tail);
+            }
+        },
+
+        
+        useShims: isIE6
+    });
+}());
+
+
+Ext.application = function(config) {
+    Ext.require('Ext.app.Application');
+
+    Ext.onReady(function() {
+        new Ext.app.Application(config);
+    });
+};
+
+//@tag extras,core
+
+//@require ../Ext-more.js
+
+//@define Ext.util.Format
+
+
+
+(function() {
+    Ext.ns('Ext.util');
+
+    Ext.util.Format = {};
+    var UtilFormat     = Ext.util.Format,
+        stripTagsRE    = /<\/?[^>]+>/gi,
+        stripScriptsRe = /(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)/ig,
+        nl2brRe        = /\r?\n/g,
+
+        
+        formatCleanRe  = /[^\d\.]/g,
+
+        
+        
+        I18NFormatCleanRe;
+
+    Ext.apply(UtilFormat, {
+        
+        
+        thousandSeparator: ',',
+        
+
+        
+        
+        decimalSeparator: '.',
+        
+
+        
+        
+        currencyPrecision: 2,
+        
+
+         
+        
+        currencySign: '$',
+        
+
+        
+        
+        currencyAtEnd: false,
+        
+
+        
+        undef : function(value) {
+            return value !== undefined ? value : "";
+        },
+
+        
+        defaultValue : function(value, defaultValue) {
+            return value !== undefined && value !== '' ? value : defaultValue;
+        },
+
+        
+        substr : 'ab'.substr(-1) != 'b'
+        ? function (value, start, length) {
+            var str = String(value);
+            return (start < 0)
+                ? str.substr(Math.max(str.length + start, 0), length)
+                : str.substr(start, length);
+        }
+        : function(value, start, length) {
+            return String(value).substr(start, length);
+        },
+
+        
+        lowercase : function(value) {
+            return String(value).toLowerCase();
+        },
+
+        
+        uppercase : function(value) {
+            return String(value).toUpperCase();
+        },
+
+        
+        usMoney : function(v) {
+            return UtilFormat.currency(v, '$', 2);
+        },
+
+        
+        currency: function(v, currencySign, decimals, end) {
+            var negativeSign = '',
+                format = ",0",
+                i = 0;
+            v = v - 0;
+            if (v < 0) {
+                v = -v;
+                negativeSign = '-';
+            }
+            decimals = Ext.isDefined(decimals) ? decimals : UtilFormat.currencyPrecision;
+            format += format + (decimals > 0 ? '.' : '');
+            for (; i < decimals; i++) {
+                format += '0';
+            }
+            v = UtilFormat.number(v, format);
+            if ((end || UtilFormat.currencyAtEnd) === true) {
+                return Ext.String.format("{0}{1}{2}", negativeSign, v, currencySign || UtilFormat.currencySign);
+            } else {
+                return Ext.String.format("{0}{1}{2}", negativeSign, currencySign || UtilFormat.currencySign, v);
+            }
+        },
+
+        
+        date: function(v, format) {
+            if (!v) {
+                return "";
+            }
+            if (!Ext.isDate(v)) {
+                v = new Date(Date.parse(v));
+            }
+            return Ext.Date.dateFormat(v, format || Ext.Date.defaultFormat);
+        },
+
+        
+        dateRenderer : function(format) {
+            return function(v) {
+                return UtilFormat.date(v, format);
+            };
+        },
+
+        
+        stripTags : function(v) {
+            return !v ? v : String(v).replace(stripTagsRE, "");
+        },
+
+        
+        stripScripts : function(v) {
+            return !v ? v : String(v).replace(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] = Ext.functionFactory('v', 'return v ' + a + ';');
+                }
+                return fns[a](v);
+            };
+        }()),
+
+        
+        round : function(value, precision) {
+            var result = Number(value);
+            if (typeof precision == 'number') {
+                precision = Math.pow(10, precision);
+                result = Math.round(value * precision) / precision;
+            }
+            return result;
+        },
+
+        
+        number : function(v, formatString) {
+            if (!formatString) {
+                return v;
+            }
+            v = Ext.Number.from(v, NaN);
+            if (isNaN(v)) {
+                return '';
+            }
+            var comma = UtilFormat.thousandSeparator,
+                dec   = UtilFormat.decimalSeparator,
+                i18n  = false,
+                neg   = v < 0,
+                hasComma,
+                psplit,
+                fnum,
+                cnum,
+                parr,
+                j,
+                m,
+                n,
+                i;
+
+            v = Math.abs(v);
+
+            
+            
+            
+            
+            if (formatString.substr(formatString.length - 2) == '/i') {
+                if (!I18NFormatCleanRe) {
+                    I18NFormatCleanRe = new RegExp('[^\\d\\' + UtilFormat.decimalSeparator + ']','g');
+                }
+                formatString = formatString.substr(0, formatString.length - 2);
+                i18n   = true;
+                hasComma = formatString.indexOf(comma) != -1;
+                psplit = formatString.replace(I18NFormatCleanRe, '').split(dec);
+            } else {
+                hasComma = formatString.indexOf(',') != -1;
+                psplit = formatString.replace(formatCleanRe, '').split('.');
+            }
+
+            if (psplit.length > 2) {
+            } else if (psplit.length > 1) {
+                v = Ext.Number.toFixed(v, psplit[1].length);
+            } else {
+                v = Ext.Number.toFixed(v, 0);
+            }
+
+            fnum = v.toString();
+
+            psplit = fnum.split('.');
+
+            if (hasComma) {
+                cnum = psplit[0];
+                parr = [];
+                j = cnum.length;
+                m = Math.floor(j / 3);
+                n = cnum.length % 3 || 3;
+
+                for (i = 0; i < j; i += n) {
+                    if (i !== 0) {
+                        n = 3;
+                    }
+
+                    parr[parr.length] = cnum.substr(i, n);
+                    m -= 1;
+                }
+                fnum = parr.join(comma);
+                if (psplit[1]) {
+                    fnum += dec + psplit[1];
+                }
+            } else {
+                if (psplit[1]) {
+                    fnum = psplit[0] + dec + psplit[1];
+                }
+            }
+
+            if (neg) {
+                
+                neg = fnum.replace(/[^1-9]/g, '') !== '';
+            }
+
+            return (neg ? '-' : '') + formatString.replace(/[\d,?\.?]+/, fnum);
+        },
+
+        
+        numberRenderer : function(format) {
+            return function(v) {
+                return UtilFormat.number(v, format);
+            };
+        },
+
+        
+        plural : function(v, s, p) {
+            return v +' ' + (v == 1 ? s : (p ? p : s+'s'));
+        },
+
+        
+        nl2br : function(v) {
+            return Ext.isEmpty(v) ? '' : v.replace(nl2brRe, '<br/>');
+        },
+
+        
+        capitalize: Ext.String.capitalize,
+
+        
+        ellipsis: Ext.String.ellipsis,
+
+        
+        format: Ext.String.format,
+
+        
+        htmlDecode: Ext.String.htmlDecode,
+
+        
+        htmlEncode: Ext.String.htmlEncode,
+
+        
+        leftPad: Ext.String.leftPad,
+
+        
+        trim : Ext.String.trim,
+
+        
+        parseBox : function(box) {
+          box = Ext.isEmpty(box) ? '' : box;
+            if (Ext.isNumber(box)) {
+                box = box.toString();
+            }
+            var parts  = box.split(' '),
+                ln = parts.length;
+
+            if (ln == 1) {
+                parts[1] = parts[2] = parts[3] = parts[0];
+            }
+            else if (ln == 2) {
+                parts[2] = parts[0];
+                parts[3] = parts[1];
+            }
+            else if (ln == 3) {
+                parts[3] = parts[1];
+            }
+
+            return {
+                top   :parseInt(parts[0], 10) || 0,
+                right :parseInt(parts[1], 10) || 0,
+                bottom:parseInt(parts[2], 10) || 0,
+                left  :parseInt(parts[3], 10) || 0
+            };
+        },
+
+        
+        escapeRegex : function(s) {
+            return s.replace(/([\-.*+?\^${}()|\[\]\/\\])/g, "\\$1");
+        }
+    });
+}());
+
+//@tag extras,core
+
+//@require Format.js
+
+//@define Ext.util.TaskManager
+
+//@define Ext.TaskManager
+
+
+
+Ext.define('Ext.util.TaskRunner', {
+    
+    interval: 10,
+
+    
+    timerId: null,
+
+    constructor: function (interval) {
+        var me = this;
+
+        if (typeof interval == 'number') {
+            me.interval = interval;
+        } else if (interval) {
+            Ext.apply(me, interval);
+        }
+
+        me.tasks = [];
+        me.timerFn = Ext.Function.bind(me.onTick, me);
+    },
+
+    
+    newTask: function (config) {
+        var task = new Ext.util.TaskRunner.Task(config);
+        task.manager = this;
+        return task;
+    },
+
+    
+    start: function(task) {
+        var me = this,
+            now = new Date().getTime();
+
+        if (!task.pending) {
+            me.tasks.push(task);
+            task.pending = true; 
+        }
+
+        task.stopped = false; 
+        task.taskStartTime = now;
+        task.taskRunTime = task.fireOnStart !== false ? 0 : task.taskStartTime;
+        task.taskRunCount = 0;
+
+        if (!me.firing) {
+            if (task.fireOnStart !== false) {
+                me.startTimer(0, now);
+            } else {
+                me.startTimer(task.interval, now);
+            }
+        }
+
+        return task;
+    },
+
+    
+    stop: function(task) {
+        
+        
+        
+        if (!task.stopped) {
+            task.stopped = true;
+
+            if (task.onStop) {
+                task.onStop.call(task.scope || task, task);
+            }
+        }
+
+        return task;
+    },
+
+    
+    stopAll: function() {
+        
+        Ext.each(this.tasks, this.stop, this);
+    },
+
+    
+
+    firing: false,
+
+    nextExpires: 1e99,
+
+    
+    onTick: function () {
+        var me = this,
+            tasks = me.tasks,
+            now = new Date().getTime(),
+            nextExpires = 1e99,
+            len = tasks.length,
+            expires, newTasks, i, task, rt, remove;
+
+        me.timerId = null;
+        me.firing = true; 
+
+        
+        
+        
+        
+        for (i = 0; i < len || i < (len = tasks.length); ++i) {
+            task = tasks[i];
+
+            if (!(remove = task.stopped)) {
+                expires = task.taskRunTime + task.interval;
+
+                if (expires <= now) {
+                    rt = 1; 
+                    try {
+                        rt = task.run.apply(task.scope || task, task.args || [++task.taskRunCount]);
+                    } catch (taskError) {
+                        try {
+                            if (task.onError) {
+                                rt = task.onError.call(task.scope || task, task, taskError);
+                            }
+                        } catch (ignore) { }
+                    }
+                    task.taskRunTime = now;
+                    if (rt === false || task.taskRunCount === task.repeat) {
+                        me.stop(task);
+                        remove = true;
+                    } else {
+                        remove = task.stopped; 
+                        expires = now + task.interval;
+                    }
+                }
+
+                if (!remove && task.duration && task.duration <= (now - task.taskStartTime)) {
+                    me.stop(task);
+                    remove = true;
+                }
+            }
+
+            if (remove) {
+                task.pending = false; 
+
+                
+                
+                
+                
+                
+                if (!newTasks) {
+                    newTasks = tasks.slice(0, i);
+                    
+                    
+                    
+                }
+            } else {
+                if (newTasks) {
+                    newTasks.push(task); 
+                }
+
+                if (nextExpires > expires) {
+                    nextExpires = expires; 
+                }
+            }
+        }
+
+        if (newTasks) {
+            
+            
+            me.tasks = newTasks;
+        }
+
+        me.firing = false; 
+
+        if (me.tasks.length) {
+            
+            
+            
+            me.startTimer(nextExpires - now, new Date().getTime());
+        }
+    },
+
+    
+    startTimer: function (timeout, now) {
+        var me = this,
+            expires = now + timeout,
+            timerId = me.timerId;
+
+        
+        
+        if (timerId && me.nextExpires - expires > me.interval) {
+            clearTimeout(timerId);
+            timerId = null;
+        }
+
+        if (!timerId) {
+            if (timeout < me.interval) {
+                timeout = me.interval;
+            }
+
+            me.timerId = setTimeout(me.timerFn, timeout);
+            me.nextExpires = expires;
+        }
+    }
+},
+function () {
+    var me = this,
+        proto = me.prototype;
+
+    
+    proto.destroy = proto.stopAll;
+
+    
+    Ext.util.TaskManager = Ext.TaskManager = new me();
+
+    
+    me.Task = new Ext.Class({
+        isTask: true,
+
+        
+        stopped: true, 
+
+        
+        fireOnStart: false,
+
+        constructor: function (config) {
+            Ext.apply(this, config);
+        },
+
+        
+        restart: function (interval) {
+            if (interval !== undefined) {
+                this.interval = interval;
+            }
+
+            this.manager.start(this);
+        },
+
+        
+        start: function (interval) {
+            if (this.stopped) {
+                this.restart(interval);
+            }
+        },
+
+        
+        stop: function () {
+            this.manager.stop(this);
+        }
+    });
+
+    proto = me.Task.prototype;
+
+    
+    proto.destroy = proto.stop;
+});
+
+//@tag extras,core
+
+//@require ../util/TaskManager.js
+
+
+
+Ext.define('Ext.perf.Accumulator', (function () {
+    var currentFrame = null,
+        khrome = Ext.global['chrome'],
+        formatTpl,
+        
+        
+        getTimestamp = function () {
+
+            getTimestamp = function () {
+                return new Date().getTime();
+            };
+            
+            var interval, toolbox;
+
+            
+            if (Ext.isChrome && khrome && khrome.Interval) {
+                interval = new khrome.Interval();
+                interval.start();
+                getTimestamp = function () {
+                    return interval.microseconds() / 1000;
+                };
+            } else if (window.ActiveXObject) {
+                try {
+                    
+                    toolbox = new ActiveXObject('SenchaToolbox.Toolbox');
+                    Ext.senchaToolbox = toolbox; 
+                    getTimestamp = function () {
+                        return toolbox.milliseconds;
+                    };
+                } catch (e) {
+                    
+                }
+            } else if (Date.now) {
+                getTimestamp = Date.now;
+            }
+
+            Ext.perf.getTimestamp = Ext.perf.Accumulator.getTimestamp = getTimestamp;
+            return getTimestamp();
+        };
+
+    function adjustSet (set, time) {
+        set.sum += time;
+        set.min = Math.min(set.min, time);
+        set.max = Math.max(set.max, time);
+    }
+
+    function leaveFrame (time) {
+        var totalTime = time ? time : (getTimestamp() - this.time), 
+            me = this, 
+            accum = me.accum;
+
+        ++accum.count;
+        if (! --accum.depth) {
+            adjustSet(accum.total, totalTime);
+        }
+        adjustSet(accum.pure, totalTime - me.childTime);
+
+        currentFrame = me.parent;
+        if (currentFrame) {
+            ++currentFrame.accum.childCount;
+            currentFrame.childTime += totalTime;
+        }
+    }
+
+    function makeSet () {
+        return {
+            min: Number.MAX_VALUE,
+            max: 0,
+            sum: 0
+        };
+    }
+
+    function makeTap (me, fn) {
+        return function () {
+            var frame = me.enter(),
+                ret = fn.apply(this, arguments);
+
+            frame.leave();
+            return ret;
+        };
+    }
+
+    function round (x) {
+        return Math.round(x * 100) / 100;
+    }
+
+    function setToJSON (count, childCount, calibration, set) {
+        var data = {
+            avg: 0,
+            min: set.min,
+            max: set.max,
+            sum: 0
+        };
+
+        if (count) {
+            calibration = calibration || 0;
+            data.sum = set.sum - childCount * calibration;
+            data.avg = data.sum / count;
+            
+            
+        }
+
+        return data;
+    }
+
+    return {
+        constructor: function (name) {
+            var me = this;
+
+            me.count = me.childCount = me.depth = me.maxDepth = 0;
+            me.pure = makeSet();
+            me.total = makeSet();
+            me.name = name;
+        },
+
+        statics: {
+            getTimestamp: getTimestamp
+        },
+
+        format: function (calibration) {
+            if (!formatTpl) {
+                formatTpl = new Ext.XTemplate([
+                        '{name} - {count} call(s)',
+                        '<tpl if="count">',
+                            '<tpl if="childCount">',
+                                ' ({childCount} children)',
+                            '</tpl>',
+                            '<tpl if="depth - 1">',
+                                ' ({depth} deep)',
+                            '</tpl>',
+                            '<tpl for="times">',
+                                ', {type}: {[this.time(values.sum)]} msec (',
+                                     
+                                     'avg={[this.time(values.sum / parent.count)]}',
+                                     
+                                     ')',
+                            '</tpl>',
+                        '</tpl>'
+                    ].join(''), {
+                        time: function (t) {
+                            return Math.round(t * 100) / 100;
+                        }
+                    });
+            }
+
+            var data = this.getData(calibration);
+            data.name = this.name;
+            data.pure.type = 'Pure';
+            data.total.type = 'Total';
+            data.times = [data.pure, data.total];
+            return formatTpl.apply(data);
+        },
+
+        getData: function (calibration) {
+            var me = this;
+
+            return {
+                count: me.count,
+                childCount: me.childCount,
+                depth: me.maxDepth,
+                pure: setToJSON(me.count, me.childCount, calibration, me.pure),
+                total: setToJSON(me.count, me.childCount, calibration, me.total)
+            };
+        },
+
+        enter: function () {
+            var me = this,
+                frame = {
+                    accum: me,
+                    leave: leaveFrame,
+                    childTime: 0,
+                    parent: currentFrame
+                };
+
+            ++me.depth;
+            if (me.maxDepth < me.depth) {
+                me.maxDepth = me.depth;
+            }
+
+            currentFrame = frame;
+            frame.time = getTimestamp(); 
+            return frame;
+        },
+
+        monitor: function (fn, scope, args) {
+            var frame = this.enter();
+            if (args) {
+                fn.apply(scope, args);
+            } else {
+                fn.call(scope);
+            }
+            frame.leave();
+        },
+
+        report: function () {
+            Ext.log(this.format());
+        },
+
+        tap: function (className, methodName) {
+            var me = this,
+                methods = typeof methodName == 'string' ? [methodName] : methodName,
+                klass, statik, i, parts, length, name, src,
+                tapFunc;
+
+            tapFunc = function(){
+                if (typeof className == 'string') {
+                    klass = Ext.global;
+                    parts = className.split('.');
+                    for (i = 0, length = parts.length; i < length; ++i) {
+                        klass = klass[parts[i]];
+                    }
+                } else {
+                    klass = className;
+                }
+
+                for (i = 0, length = methods.length; i < length; ++i) {
+                    name = methods[i];
+                    statik = name.charAt(0) == '!';
+
+                    if (statik) {
+                        name = name.substring(1);
+                    } else {
+                        statik = !(name in klass.prototype);
+                    }
+
+                    src = statik ? klass : klass.prototype;
+                    src[name] = makeTap(me, src[name]);
+                }
+            };
+
+            Ext.ClassManager.onCreated(tapFunc, me, className);
+
+            return me;
+        }
+    };
+}()),
+
+function () {
+    Ext.perf.getTimestamp = this.getTimestamp;
+});
+
+//@tag extras,core
+
+//@require Accumulator.js
+
+
+
+Ext.define('Ext.perf.Monitor', {
+    singleton: true,
+    alternateClassName: 'Ext.Perf',
+
+    requires: [
+        'Ext.perf.Accumulator'
+    ],
+
+    constructor: function () {
+        this.accumulators = [];
+        this.accumulatorsByName = {};
+    },
+
+    calibrate: function () {
+        var accum = new Ext.perf.Accumulator('$'),
+            total = accum.total,
+            getTimestamp = Ext.perf.Accumulator.getTimestamp,
+            count = 0,
+            frame,
+            endTime,
+            startTime;
+
+        startTime = getTimestamp();
+
+        do {
+            frame = accum.enter();
+            frame.leave();
+            ++count;
+        } while (total.sum < 100);
+
+        endTime = getTimestamp();
+
+        return (endTime - startTime) / count;
+    },
+
+    get: function (name) {
+        var me = this,
+            accum = me.accumulatorsByName[name];
+
+        if (!accum) {
+            me.accumulatorsByName[name] = accum = new Ext.perf.Accumulator(name);
+            me.accumulators.push(accum);
+        }
+
+        return accum;
+    },
+
+    enter: function (name) {
+        return this.get(name).enter();
+    },
+
+    monitor: function (name, fn, scope) {
+        this.get(name).monitor(fn, scope);
+    },
+
+    report: function () {
+        var me = this,
+            accumulators = me.accumulators,
+            calibration = me.calibrate();
+
+        accumulators.sort(function (a, b) {
+            return (a.name < b.name) ? -1 : ((b.name < a.name) ? 1 : 0);
+        });
+
+        me.updateGC();
+
+        Ext.log('Calibration: ' + Math.round(calibration * 100) / 100 + ' msec/sample');
+        Ext.each(accumulators, function (accum) {
+            Ext.log(accum.format(calibration));
+        });
+    },
+
+    getData: function (all) {
+        var ret = {},
+            accumulators = this.accumulators;
+
+        Ext.each(accumulators, function (accum) {
+            if (all || accum.count) {
+                ret[accum.name] = accum.getData();
+            }
+        });
+
+        return ret;
+    },
+
+    reset: function(){
+        Ext.each(this.accumulators, function(accum){
+            var me = accum;
+            me.count = me.childCount = me.depth = me.maxDepth = 0;
+            me.pure = {
+                min: Number.MAX_VALUE,
+                max: 0,
+                sum: 0
+            };
+            me.total = {
+                min: Number.MAX_VALUE,
+                max: 0,
+                sum: 0
+            };
+        });
+    },
+
+    updateGC: function () {
+        var accumGC = this.accumulatorsByName.GC,
+            toolbox = Ext.senchaToolbox,
+            bucket;
+
+        if (accumGC) {
+            accumGC.count = toolbox.garbageCollectionCounter || 0;
+
+            if (accumGC.count) {
+                bucket = accumGC.pure;
+                accumGC.total.sum = bucket.sum = toolbox.garbageCollectionMilliseconds;
+                bucket.min = bucket.max = bucket.sum / accumGC.count;
+                bucket = accumGC.total;
+                bucket.min = bucket.max = bucket.sum / accumGC.count;
+            }
+        }
+    },
+
+    watchGC: function () {
+        Ext.perf.getTimestamp(); 
+
+        var toolbox = Ext.senchaToolbox;
+
+        if (toolbox) {
+            this.get("GC");
+            toolbox.watchGarbageCollector(false); 
+        }
+    },
+
+    setup: function (config) {
+        if (!config) {
+            config = {
+                
+                
+
+
+
+
+
+
+                render: {
+                    'Ext.AbstractComponent': 'render'
+                },
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+                layout: {
+                    'Ext.layout.Context': 'run'
+                }
+            };
+        }
+
+        this.currentConfig = config;
+
+        var key, prop,
+            accum, className, methods;
+        for (key in config) {
+            if (config.hasOwnProperty(key)) {
+                prop = config[key];
+                accum = Ext.Perf.get(key);
+
+                for (className in prop) {
+                    if (prop.hasOwnProperty(className)) {
+                        methods = prop[className];
+                        accum.tap(className, methods);
+                    }
+                }
+            }
+        }
+
+        this.watchGC();
+    }
+});
+
+//@tag extras,core
+
+//@require perf/Monitor.js
+
+//@define Ext.Supports
+
+
+
+Ext.is = {
+    init : function(navigator) {
+        var platforms = this.platforms,
+            ln = platforms.length,
+            i, platform;
+
+        navigator = navigator || window.navigator;
+
+        for (i = 0; i < ln; i++) {
+            platform = platforms[i];
+            this[platform.identity] = platform.regex.test(navigator[platform.property]);
+        }
+
+        
+        this.Desktop = this.Mac || this.Windows || (this.Linux && !this.Android);
+        
+        this.Tablet = this.iPad;
+        
+        this.Phone = !this.Desktop && !this.Tablet;
+        
+        this.iOS = this.iPhone || this.iPad || this.iPod;
+        
+        
+        this.Standalone = !!window.navigator.standalone;
+    },
+    
+    
+    platforms: [{
+        property: 'platform',
+        regex: /iPhone/i,
+        identity: 'iPhone'
+    },
+    
+    
+    {
+        property: 'platform',
+        regex: /iPod/i,
+        identity: 'iPod'
+    },
+    
+    
+    {
+        property: 'userAgent',
+        regex: /iPad/i,
+        identity: 'iPad'
+    },
+    
+    
+    {
+        property: 'userAgent',
+        regex: /Blackberry/i,
+        identity: 'Blackberry'
+    },
+    
+    
+    {
+        property: 'userAgent',
+        regex: /Android/i,
+        identity: 'Android'
+    },
+    
+    
+    {
+        property: 'platform',
+        regex: /Mac/i,
+        identity: 'Mac'
+    },
+    
+    
+    {
+        property: 'platform',
+        regex: /Win/i,
+        identity: 'Windows'
+    },
+    
+    
+    {
+        property: 'platform',
+        regex: /Linux/i,
+        identity: 'Linux'
+    }]
+};
+
+Ext.is.init();
+
+
+(function(){
+
+    
+    
+    
+    var getStyle = function(element, styleName){
+        var view = element.ownerDocument.defaultView,
+            style = (view ? view.getComputedStyle(element, null) : element.currentStyle) || element.style;
+        return style[styleName];
+    };
+
+Ext.supports = {
+    
+    init : function() {
+        var me = this,
+            doc = document,
+            tests = me.tests,
+            n = tests.length,
+            div = n && Ext.isReady && doc.createElement('div'),
+            test, notRun = [];
+
+        if (div) {
+            div.innerHTML = [
+                '<div style="height:30px;width:50px;">',
+                    '<div style="height:20px;width:20px;"></div>',
+                '</div>',
+                '<div style="width: 200px; height: 200px; position: relative; padding: 5px;">',
+                    '<div style="position: absolute; top: 0; left: 0; width: 100%; height: 100%;"></div>',
+                '</div>',
+                '<div style="position: absolute; left: 10%; top: 10%;"></div>',
+                '<div style="float:left; background-color:transparent;"></div>'
+            ].join('');
+
+            doc.body.appendChild(div);
+        }
+
+        while (n--) {
+            test = tests[n];
+            if (div || test.early) {
+                me[test.identity] = test.fn.call(me, doc, div);
+            } else {
+                notRun.push(test);
+            }
+        }
+
+        if (div) {
+            doc.body.removeChild(div);
+        }
+
+        me.tests = notRun;
+    },
+
+    
+    PointerEvents: 'pointerEvents' in document.documentElement.style,
+
+    
+    CSS3BoxShadow: 'boxShadow' in document.documentElement.style || 'WebkitBoxShadow' in document.documentElement.style || 'MozBoxShadow' in document.documentElement.style,
+
+    
+    ClassList: !!document.documentElement.classList,
+
+    
+    OrientationChange: ((typeof window.orientation != 'undefined') && ('onorientationchange' in window)),
+
+    
+    DeviceMotion: ('ondevicemotion' in window),
+
+    
+    
+    
+    Touch: ('ontouchstart' in window) && (!Ext.is.Desktop),
+
+    
+    TimeoutActualLateness: (function(){
+        setTimeout(function(){
+            Ext.supports.TimeoutActualLateness = arguments.length !== 0;
+        }, 0);
+    }()),
+
+    tests: [
+        
+        {
+            identity: 'Transitions',
+            fn: function(doc, div) {
+                var prefix = [
+                        'webkit',
+                        'Moz',
+                        'o',
+                        'ms',
+                        'khtml'
+                    ],
+                    TE = 'TransitionEnd',
+                    transitionEndName = [
+                        prefix[0] + TE,
+                        'transitionend', 
+                        prefix[2] + TE,
+                        prefix[3] + TE,
+                        prefix[4] + TE
+                    ],
+                    ln = prefix.length,
+                    i = 0,
+                    out = false;
+
+                for (; i < ln; i++) {
+                    if (getStyle(div, prefix[i] + "TransitionProperty")) {
+                        Ext.supports.CSS3Prefix = prefix[i];
+                        Ext.supports.CSS3TransitionEnd = transitionEndName[i];
+                        out = true;
+                        break;
+                    }
+                }
+                return out;
+            }
+        },
+
+        
+        {
+            identity: 'RightMargin',
+            fn: function(doc, div) {
+                var view = doc.defaultView;
+                return !(view && view.getComputedStyle(div.firstChild.firstChild, null).marginRight != '0px');
+            }
+        },
+
+        
+        {
+            identity: 'DisplayChangeInputSelectionBug',
+            early: true,
+            fn: function() {
+                var webKitVersion = Ext.webKitVersion;
+                
+                return 0 < webKitVersion && webKitVersion < 533;
+            }
+        },
+
+        
+        {
+            identity: 'DisplayChangeTextAreaSelectionBug',
+            early: true,
+            fn: function() {
+                var webKitVersion = Ext.webKitVersion;
+
+                
+                return 0 < webKitVersion && webKitVersion < 534.24;
+            }
+        },
+
+        
+        {
+            identity: 'TransparentColor',
+            fn: function(doc, div, view) {
+                view = doc.defaultView;
+                return !(view && view.getComputedStyle(div.lastChild, null).backgroundColor != 'transparent');
+            }
+        },
+
+        
+        {
+            identity: 'ComputedStyle',
+            fn: function(doc, div, view) {
+                view = doc.defaultView;
+                return view && view.getComputedStyle;
+            }
+        },
+
+        
+        {
+            identity: 'Svg',
+            fn: function(doc) {
+                return !!doc.createElementNS && !!doc.createElementNS( "http:/" + "/www.w3.org/2000/svg", "svg").createSVGRect;
+            }
+        },
+
+        
+        {
+            identity: 'Canvas',
+            fn: function(doc) {
+                return !!doc.createElement('canvas').getContext;
+            }
+        },
+
+        
+        {
+            identity: 'Vml',
+            fn: function(doc) {
+                var d = doc.createElement("div");
+                d.innerHTML = "<!--[if vml]><br/><br/><![endif]-->";
+                return (d.childNodes.length == 2);
+            }
+        },
+
+        
+        {
+            identity: 'Float',
+            fn: function(doc, div) {
+                return !!div.lastChild.style.cssFloat;
+            }
+        },
+
+        
+        {
+            identity: 'AudioTag',
+            fn: function(doc) {
+                return !!doc.createElement('audio').canPlayType;
+            }
+        },
+
+        
+        {
+            identity: 'History',
+            fn: function() {
+                var history = window.history;
+                return !!(history && history.pushState);
+            }
+        },
+
+        
+        {
+            identity: 'CSS3DTransform',
+            fn: function() {
+                return (typeof WebKitCSSMatrix != 'undefined' && new WebKitCSSMatrix().hasOwnProperty('m41'));
+            }
+        },
+
+		
+        {
+            identity: 'CSS3LinearGradient',
+            fn: function(doc, div) {
+                var property = 'background-image:',
+                    webkit   = '-webkit-gradient(linear, left top, right bottom, from(black), to(white))',
+                    w3c      = 'linear-gradient(left top, black, white)',
+                    moz      = '-moz-' + w3c,
+                    opera    = '-o-' + w3c,
+                    options  = [property + webkit, property + w3c, property + moz, property + opera];
+
+                div.style.cssText = options.join(';');
+
+                return ("" + div.style.backgroundImage).indexOf('gradient') !== -1;
+            }
+        },
+
+        
+        {
+            identity: 'CSS3BorderRadius',
+            fn: function(doc, div) {
+                var domPrefixes = ['borderRadius', 'BorderRadius', 'MozBorderRadius', 'WebkitBorderRadius', 'OBorderRadius', 'KhtmlBorderRadius'],
+                    pass = false,
+                    i;
+                for (i = 0; i < domPrefixes.length; i++) {
+                    if (document.body.style[domPrefixes[i]] !== undefined) {
+                        return true;
+                    }
+                }
+                return pass;
+            }
+        },
+
+        
+        {
+            identity: 'GeoLocation',
+            fn: function() {
+                return (typeof navigator != 'undefined' && typeof navigator.geolocation != 'undefined') || (typeof google != 'undefined' && typeof google.gears != 'undefined');
+            }
+        },
+        
+        {
+            identity: 'MouseEnterLeave',
+            fn: function(doc, div){
+                return ('onmouseenter' in div && 'onmouseleave' in div);
+            }
+        },
+        
+        {
+            identity: 'MouseWheel',
+            fn: function(doc, div) {
+                return ('onmousewheel' in div);
+            }
+        },
+        
+        {
+            identity: 'Opacity',
+            fn: function(doc, div){
+                
+                if (Ext.isIE6 || Ext.isIE7 || Ext.isIE8) {
+                    return false;
+                }
+                div.firstChild.style.cssText = 'opacity:0.73';
+                return div.firstChild.style.opacity == '0.73';
+            }
+        },
+        
+        {
+            identity: 'Placeholder',
+            fn: function(doc) {
+                return 'placeholder' in doc.createElement('input');
+            }
+        },
+
+        
+        {
+            identity: 'Direct2DBug',
+            fn: function() {
+                return Ext.isString(document.body.style.msTransformOrigin);
+            }
+        },
+        
+        {
+            identity: 'BoundingClientRect',
+            fn: function(doc, div) {
+                return Ext.isFunction(div.getBoundingClientRect);
+            }
+        },
+        {
+            identity: 'IncludePaddingInWidthCalculation',
+            fn: function(doc, div){
+                return div.childNodes[1].firstChild.offsetWidth == 210;
+            }
+        },
+        {
+            identity: 'IncludePaddingInHeightCalculation',
+            fn: function(doc, div){
+                return div.childNodes[1].firstChild.offsetHeight == 210;
+            }
+        },
+
+        
+        {
+            identity: 'ArraySort',
+            fn: function() {
+                var a = [1,2,3,4,5].sort(function(){ return 0; });
+                return a[0] === 1 && a[1] === 2 && a[2] === 3 && a[3] === 4 && a[4] === 5;
+            }
+        },
+        
+        {
+            identity: 'Range',
+            fn: function() {
+                return !!document.createRange;
+            }
+        },
+        
+        {
+            identity: 'CreateContextualFragment',
+            fn: function() {
+                var range = Ext.supports.Range ? document.createRange() : false;
+
+                return range && !!range.createContextualFragment;
+            }
+        },
+
+        
+        {
+            identity: 'WindowOnError',
+            fn: function () {
+                
+                return Ext.isIE || Ext.isGecko || Ext.webKitVersion >= 534.16; 
+            }
+        },
+
+        
+        {
+            identity: 'TextAreaMaxLength',
+            fn: function(){
+                var el = document.createElement('textarea');
+                return ('maxlength' in el);
+            }
+        },
+        
+        
+        {
+            identity: 'GetPositionPercentage',
+            fn: function(doc, div){
+               return getStyle(div.childNodes[2], 'left') == '10%';
+            }
+        }
+    ]
+};
+}());
+
+Ext.supports.init(); 
+
+//@tag dom,core
+
+//@require ../Support.js
+
+//@define Ext.util.DelayedTask
+
+
+
+Ext.util.DelayedTask = function(fn, scope, args) {
+    var me = this,
+        id,
+        call = function() {
+            clearInterval(id);
+            id = null;
+            fn.apply(scope, args || []);
+        };
+
+    
+    this.delay = function(delay, newFn, newScope, newArgs) {
+        me.cancel();
+        fn = newFn || fn;
+        scope = newScope || scope;
+        args = newArgs || args;
+        id = setInterval(call, delay);
+    };
+
+    
+    this.cancel = function(){
+        if (id) {
+            clearInterval(id);
+            id = null;
+        }
+    };
+};
+
+//@tag dom,core
+
+//@define Ext.util.Event
+
+//@require Ext.util.DelayedTask
+
+
+Ext.require('Ext.util.DelayedTask', function() {
+
+    
+    Ext.util.Event = Ext.extend(Object, (function() {
+        var noOptions = {};
+
+        function createTargeted(handler, listener, o, scope){
+            return function(){
+                if (o.target === arguments[0]){
+                    handler.apply(scope, arguments);
+                }
+            };
+        }
+
+        function createBuffered(handler, listener, o, scope) {
+            listener.task = new Ext.util.DelayedTask();
+            return function() {
+                listener.task.delay(o.buffer, handler, scope, Ext.Array.toArray(arguments));
+            };
+        }
+
+        function createDelayed(handler, listener, o, scope) {
+            return function() {
+                var task = new Ext.util.DelayedTask();
+                if (!listener.tasks) {
+                    listener.tasks = [];
+                }
+                listener.tasks.push(task);
+                task.delay(o.delay || 10, handler, scope, Ext.Array.toArray(arguments));
+            };
+        }
+
+        function createSingle(handler, listener, o, scope) {
+            return function() {
+                var event = listener.ev;
+
+                if (event.removeListener(listener.fn, scope) && event.observable) {
+                    
+                    
+                    event.observable.hasListeners[event.name]--;
+                }
+
+                return handler.apply(scope, arguments);
+            };
+        }
+
+        return {
+            
+            isEvent: true,
+
+            constructor: function(observable, name) {
+                this.name = name;
+                this.observable = observable;
+                this.listeners = [];
+            },
+
+            addListener: function(fn, scope, options) {
+                var me = this,
+                    listener;
+                    scope = scope || me.observable;
+
+
+                if (!me.isListening(fn, scope)) {
+                    listener = me.createListener(fn, scope, options);
+                    if (me.firing) {
+                        
+                        me.listeners = me.listeners.slice(0);
+                    }
+                    me.listeners.push(listener);
+                }
+            },
+
+            createListener: function(fn, scope, options) {
+                options = options || noOptions;
+                scope = scope || this.observable;
+
+                var listener = {
+                        fn: fn,
+                        scope: scope,
+                        o: options,
+                        ev: this
+                    },
+                    handler = fn;
+
+                
+                
+                if (options.single) {
+                    handler = createSingle(handler, listener, options, scope);
+                }
+                if (options.target) {
+                    handler = createTargeted(handler, listener, options, scope);
+                }
+                if (options.delay) {
+                    handler = createDelayed(handler, listener, options, scope);
+                }
+                if (options.buffer) {
+                    handler = createBuffered(handler, listener, options, scope);
+                }
+
+                listener.fireFn = handler;
+                return listener;
+            },
+
+            findListener: function(fn, scope) {
+                var listeners = this.listeners,
+                i = listeners.length,
+                listener,
+                s;
+
+                while (i--) {
+                    listener = listeners[i];
+                    if (listener) {
+                        s = listener.scope;
+
+                        
+                        
+                        
+                        if (listener.fn == fn && (s == (scope || this.observable))) {
+                            return i;
+                        }
+                    }
+                }
+
+                return - 1;
+            },
+
+            isListening: function(fn, scope) {
+                return this.findListener(fn, scope) !== -1;
+            },
+
+            removeListener: function(fn, scope) {
+                var me = this,
+                    index,
+                    listener,
+                    k;
+                index = me.findListener(fn, scope);
+                if (index != -1) {
+                    listener = me.listeners[index];
+
+                    if (me.firing) {
+                        me.listeners = me.listeners.slice(0);
+                    }
+
+                    
+                    if (listener.task) {
+                        listener.task.cancel();
+                        delete listener.task;
+                    }
+
+                    
+                    k = listener.tasks && listener.tasks.length;
+                    if (k) {
+                        while (k--) {
+                            listener.tasks[k].cancel();
+                        }
+                        delete listener.tasks;
+                    }
+
+                    
+                    Ext.Array.erase(me.listeners, index, 1);
+                    return true;
+                }
+
+                return false;
+            },
+
+            
+            clearListeners: function() {
+                var listeners = this.listeners,
+                    i = listeners.length;
+
+                while (i--) {
+                    this.removeListener(listeners[i].fn, listeners[i].scope);
+                }
+            },
+
+            fire: function() {
+                var me = this,
+                    listeners = me.listeners,
+                    count = listeners.length,
+                    i,
+                    args,
+                    listener;
+
+                if (count > 0) {
+                    me.firing = true;
+                    for (i = 0; i < count; i++) {
+                        listener = listeners[i];
+                        args = arguments.length ? Array.prototype.slice.call(arguments, 0) : [];
+                        if (listener.o) {
+                            args.push(listener.o);
+                        }
+                        if (listener && listener.fireFn.apply(listener.scope || me.observable, args) === false) {
+                            return (me.firing = false);
+                        }
+                    }
+                }
+                me.firing = false;
+                return true;
+            }
+        };
+    }()));
+});
+
+
+Ext.define('Ext.util.Observable', {
+
+    
+
+    requires: ['Ext.util.Event'],
+
+    statics: {
+        
+        releaseCapture: function(o) {
+            o.fireEvent = this.prototype.fireEvent;
+        },
+
+        
+        capture: function(o, fn, scope) {
+            o.fireEvent = Ext.Function.createInterceptor(o.fireEvent, fn, scope);
+        },
+
+        
+        observe: function(cls, listeners) {
+            if (cls) {
+                if (!cls.isObservable) {
+                    Ext.applyIf(cls, new this());
+                    this.capture(cls.prototype, cls.fireEvent, cls);
+                }
+                if (Ext.isObject(listeners)) {
+                    cls.on(listeners);
+                }
+            }
+            return cls;
+        },
+
+        
+        prepareClass: function (T, mixin) {
+            
+            
+
+            
+            
+
+            if (!T.HasListeners) {
+                
+                
+                
+                var Observable = Ext.util.Observable,
+                    HasListeners = function () {},
+                    SuperHL = T.superclass.HasListeners || (mixin && mixin.HasListeners) ||
+                              Observable.HasListeners;
+
+                
+                T.prototype.HasListeners = T.HasListeners = HasListeners;
+
+                
+                
+                HasListeners.prototype = T.hasListeners = new SuperHL();
+            }
+        }
+    },
+
+    
+
+    
+
+    
+    isObservable: true,
+
+    
+    eventsSuspended: 0,
+
+    
+
+    constructor: function(config) {
+        var me = this;
+
+        Ext.apply(me, config);
+
+        
+        if (!me.hasListeners) {
+            me.hasListeners = new me.HasListeners();
+        }
+
+        me.events = me.events || {};
+        if (me.listeners) {
+            me.on(me.listeners);
+            me.listeners = null; 
+        }
+
+        if (me.bubbleEvents) {
+            me.enableBubble(me.bubbleEvents);
+        }
+    },
+
+    onClassExtended: function (T) {
+        if (!T.HasListeners) {
+            
+            
+            Ext.util.Observable.prepareClass(T);
+        }
+    },
+
+    
+    eventOptionsRe : /^(?:scope|delay|buffer|single|stopEvent|preventDefault|stopPropagation|normalized|args|delegate|element|vertical|horizontal|freezeEvent)$/,
+
+    
+    addManagedListener : function(item, ename, fn, scope, options) {
+        var me = this,
+            managedListeners = me.managedListeners = me.managedListeners || [],
+            config;
+
+        if (typeof ename !== 'string') {
+            options = ename;
+            for (ename in options) {
+                if (options.hasOwnProperty(ename)) {
+                    config = options[ename];
+                    if (!me.eventOptionsRe.test(ename)) {
+                        me.addManagedListener(item, ename, config.fn || config, config.scope || options.scope, config.fn ? config : options);
+                    }
+                }
+            }
+        }
+        else {
+            managedListeners.push({
+                item: item,
+                ename: ename,
+                fn: fn,
+                scope: scope,
+                options: options
+            });
+
+            item.on(ename, fn, scope, options);
+        }
+    },
+
+    
+    removeManagedListener : function(item, ename, fn, scope) {
+        var me = this,
+            options,
+            config,
+            managedListeners,
+            length,
+            i;
+
+        if (typeof ename !== 'string') {
+            options = ename;
+            for (ename in options) {
+                if (options.hasOwnProperty(ename)) {
+                    config = options[ename];
+                    if (!me.eventOptionsRe.test(ename)) {
+                        me.removeManagedListener(item, ename, config.fn || config, config.scope || options.scope);
+                    }
+                }
+            }
+        }
+
+        managedListeners = me.managedListeners ? me.managedListeners.slice() : [];
+
+        for (i = 0, length = managedListeners.length; i < length; i++) {
+            me.removeManagedListenerItem(false, managedListeners[i], item, ename, fn, scope);
+        }
+    },
+
+    
+    fireEvent: function(eventName) {
+        eventName = eventName.toLowerCase();
+        var me = this,
+            events = me.events,
+            event = events && events[eventName],
+            ret = true;
+
+        
+        
+        if (event && me.hasListeners[eventName]) {
+            ret = me.continueFireEvent(eventName, Ext.Array.slice(arguments, 1), event.bubble);
+        }
+        return ret;
+    },
+
+    
+    continueFireEvent: function(eventName, args, bubbles) {
+        var target = this,
+            queue, event,
+            ret = true;
+
+        do {
+            if (target.eventsSuspended) {
+                if ((queue = target.eventQueue)) {
+                    queue.push([eventName, args, bubbles]);
+                }
+                return ret;
+            } else {
+                event = target.events[eventName];
+                
+                
+                if (event && event != true) {
+                    if ((ret = event.fire.apply(event, args)) === false) {
+                        break;
+                    }
+                }
+            }
+        } while (bubbles && (target = target.getBubbleParent()));
+        return ret;
+    },
+
+    
+    getBubbleParent: function(){
+        var me = this, parent = me.getBubbleTarget && me.getBubbleTarget();
+        if (parent && parent.isObservable) {
+            return parent;
+        }
+        return null;
+    },
+
+    
+    addListener: function(ename, fn, scope, options) {
+        var me = this,
+            config, event, hasListeners,
+            prevListenerCount = 0;
+
+        if (typeof ename !== 'string') {
+            options = ename;
+            for (ename in options) {
+                if (options.hasOwnProperty(ename)) {
+                    config = options[ename];
+                    if (!me.eventOptionsRe.test(ename)) {
+                        me.addListener(ename, config.fn || config, config.scope || options.scope, config.fn ? config : options);
+                    }
+                }
+            }
+        } else {
+            ename = ename.toLowerCase();
+            event = me.events[ename];
+            if (event && event.isEvent) {
+                prevListenerCount = event.listeners.length;
+            } else {
+                me.events[ename] = event = new Ext.util.Event(me, ename);
+            }
+
+            
+            if (typeof fn === 'string') {
+                fn = scope[fn] || me[fn];
+            }
+            event.addListener(fn, scope, options);
+
+            
+            
+            if (event.listeners.length !== prevListenerCount) {
+                hasListeners = me.hasListeners;
+                if (hasListeners.hasOwnProperty(ename)) {
+                    
+                    ++hasListeners[ename];
+                } else {
+                    
+                    
+                    hasListeners[ename] = 1;
+                }
+            }
+        }
+    },
+
+    
+    removeListener: function(ename, fn, scope) {
+        var me = this,
+            config,
+            event,
+            options;
+
+        if (typeof ename !== 'string') {
+            options = ename;
+            for (ename in options) {
+                if (options.hasOwnProperty(ename)) {
+                    config = options[ename];
+                    if (!me.eventOptionsRe.test(ename)) {
+                        me.removeListener(ename, config.fn || config, config.scope || options.scope);
+                    }
+                }
+            }
+        } else {
+            ename = ename.toLowerCase();
+            event = me.events[ename];
+            if (event && event.isEvent) {
+                if (event.removeListener(fn, scope) && !--me.hasListeners[ename]) {
+                    
+                    
+                    
+                    delete me.hasListeners[ename];
+                }
+            }
+        }
+    },
+
+    
+    clearListeners: function() {
+        var events = this.events,
+            event,
+            key;
+
+        for (key in events) {
+            if (events.hasOwnProperty(key)) {
+                event = events[key];
+                if (event.isEvent) {
+                    event.clearListeners();
+                }
+            }
+        }
+
+        this.clearManagedListeners();
+    },
+
+
+    
+    clearManagedListeners : function() {
+        var managedListeners = this.managedListeners || [],
+            i = 0,
+            len = managedListeners.length;
+
+        for (; i < len; i++) {
+            this.removeManagedListenerItem(true, managedListeners[i]);
+        }
+
+        this.managedListeners = [];
+    },
+
+    
+    removeManagedListenerItem: function(isClear, managedListener, item, ename, fn, scope){
+        if (isClear || (managedListener.item === item && managedListener.ename === ename && (!fn || managedListener.fn === fn) && (!scope || managedListener.scope === scope))) {
+            managedListener.item.un(managedListener.ename, managedListener.fn, managedListener.scope);
+            if (!isClear) {
+                Ext.Array.remove(this.managedListeners, managedListener);
+            }
+        }
+    },
+
+
+    
+    addEvents: function(o) {
+        var me = this,
+            events = me.events || (me.events = {}),
+            arg, args, i;
+
+        if (typeof o == 'string') {
+            for (args = arguments, i = args.length; i--; ) {
+                arg = args[i];
+                if (!events[arg]) {
+                    events[arg] = true;
+                }
+            }
+        } else {
+            Ext.applyIf(me.events, o);
+        }
+    },
+
+    
+    hasListener: function(ename) {
+        return !!this.hasListeners[ename.toLowerCase()];
+    },
+
+    
+    suspendEvents: function(queueSuspended) {
+        this.eventsSuspended += 1;
+        if (queueSuspended && !this.eventQueue) {
+            this.eventQueue = [];
+        }
+    },
+
+    
+    resumeEvents: function() {
+        var me = this,
+            queued = me.eventQueue,
+            qLen, q;
+
+        if (me.eventsSuspended && ! --me.eventsSuspended) {
+            delete me.eventQueue;
+
+            if (queued) {
+                qLen = queued.length;
+                for (q = 0; q < qLen; q++) {
+                    me.continueFireEvent.apply(me, queued[q]);
+                }
+            }
+        }
+    },
+
+    
+    relayEvents : function(origin, events, prefix) {
+        var me = this,
+            len = events.length,
+            i = 0,
+            oldName,
+            newName;
+
+        for (; i < len; i++) {
+            oldName = events[i];
+            newName = prefix ? prefix + oldName : oldName;
+
+            
+            me.mon(origin, oldName, me.createRelayer(newName));
+        }
+    },
+
+    
+    createRelayer: function(newName, beginEnd){
+        var me = this;
+        return function() {
+            return me.fireEvent.apply(me, [newName].concat(Array.prototype.slice.apply(arguments, beginEnd || [0, -1])));
+        };
+    },
+
+    
+    enableBubble: function(eventNames) {
+        if (eventNames) {
+            var me = this,
+                names = (typeof eventNames == 'string') ? arguments : eventNames,
+                length = names.length,
+                events = me.events,
+                ename, event, i;
+
+            for (i = 0; i < length; ++i) {
+                ename = names[i].toLowerCase();
+                event = events[ename];
+
+                if (!event || typeof event == 'boolean') {
+                    events[ename] = event = new Ext.util.Event(me, ename);
+                }
+
+                
+                me.hasListeners[ename] = (me.hasListeners[ename]||0) + 1;
+
+                event.bubble = true;
+            }
+        }
+    }
+}, function() {
+    var Observable = this,
+        proto = Observable.prototype,
+        HasListeners = function () {},
+        prepareMixin = function (T) {
+            if (!T.HasListeners) {
+                var proto = T.prototype;
+
+                
+                Observable.prepareClass(T, this);
+
+                
+                
+                T.onExtended(function (U) {
+                    Observable.prepareClass(U);
+                });
+
+                
+                
+                if (proto.onClassMixedIn) {
+                    
+                    Ext.override(T, {
+                        onClassMixedIn: function (U) {
+                            prepareMixin.call(this, U);
+                            this.callParent(arguments);
+                        }
+                    });
+                } else {
+                    
+                    proto.onClassMixedIn = function (U) {
+                        prepareMixin.call(this, U);
+                    };
+                }
+            }
+        };
+
+    HasListeners.prototype = {
+        
+    };
+
+    proto.HasListeners = Observable.HasListeners = HasListeners;
+
+    Observable.createAlias({
+        
+        on: 'addListener',
+        
+        un: 'removeListener',
+        
+        mon: 'addManagedListener',
+        
+        mun: 'removeManagedListener'
+    });
+
+    
+    Observable.observeClass = Observable.observe;
+
+    
+    
+    
+    function getMethodEvent(method){
+        var e = (this.methodEvents = this.methodEvents || {})[method],
+            returnValue,
+            v,
+            cancel,
+            obj = this,
+            makeCall;
+
+        if (!e) {
+            this.methodEvents[method] = e = {};
+            e.originalFn = this[method];
+            e.methodName = method;
+            e.before = [];
+            e.after = [];
+
+            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;
+                        }
+                        cancel = !!v.cancel;
+                    }
+                    else
+                        if (v === false) {
+                            cancel = true;
+                        }
+                        else {
+                            returnValue = v;
+                        }
+                }
+            };
+
+            this[method] = function(){
+                var args = Array.prototype.slice.call(arguments, 0),
+                    b, i, len;
+                returnValue = v = undefined;
+                cancel = false;
+
+                for(i = 0, len = e.before.length; i < len; i++){
+                    b = e.before[i];
+                    makeCall(b.fn, b.scope, args);
+                    if (cancel) {
+                        return returnValue;
+                    }
+                }
+
+                if((v = e.originalFn.apply(obj, args)) !== undefined){
+                    returnValue = v;
+                }
+
+                for(i = 0, len = e.after.length; i < len; i++){
+                    b = e.after[i];
+                    makeCall(b.fn, b.scope, args);
+                    if (cancel) {
+                        return returnValue;
+                    }
+                }
+                return returnValue;
+            };
+        }
+        return e;
+    }
+
+    Ext.apply(proto, {
+        onClassMixedIn: prepareMixin,
+
+        
+        
+        
+        beforeMethod : function(method, fn, scope){
+            getMethodEvent.call(this, method).before.push({
+                fn: fn,
+                scope: scope
+            });
+        },
+
+        
+        afterMethod : function(method, fn, scope){
+            getMethodEvent.call(this, method).after.push({
+                fn: fn,
+                scope: scope
+            });
+        },
+
+        removeMethodListener: function(method, fn, scope){
+            var e = this.getMethodEvent(method),
+                i, len;
+            for(i = 0, len = e.before.length; i < len; i++){
+                if(e.before[i].fn == fn && e.before[i].scope == scope){
+                    Ext.Array.erase(e.before, i, 1);
+                    return;
+                }
+            }
+            for(i = 0, len = e.after.length; i < len; i++){
+                if(e.after[i].fn == fn && e.after[i].scope == scope){
+                    Ext.Array.erase(e.after, i, 1);
+                    return;
+                }
+            }
+        },
+
+        toggleEventLogging: function(toggle) {
+            Ext.util.Observable[toggle ? 'capture' : 'releaseCapture'](this, function(en) {
+                if (Ext.isDefined(Ext.global.console)) {
+                    Ext.global.console.log(en, arguments);
+                }
+            });
+        }
+    });
+});
+
+
+Ext.define('Ext.util.HashMap', {
+    mixins: {
+        observable: 'Ext.util.Observable'
+    },
+
+    
+
+    
+    constructor: function(config) {
+        config = config || {};
+
+        var me = this,
+            keyFn = config.keyFn;
+
+        me.addEvents(
+            
+            'add',
+            
+            'clear',
+            
+            'remove',
+            
+            'replace'
+        );
+
+        me.mixins.observable.constructor.call(me, config);
+        me.clear(true);
+
+        if (keyFn) {
+            me.getKey = keyFn;
+        }
+    },
+
+    
+    getCount: function() {
+        return this.length;
+    },
+
+    
+    getData: function(key, value) {
+        
+        if (value === undefined) {
+            value = key;
+            key = this.getKey(value);
+        }
+
+        return [key, value];
+    },
+
+    
+    getKey: function(o) {
+        return o.id;
+    },
+
+    
+    add: function(key, value) {
+        var me = this;
+
+        if (value === undefined) {
+            value = key;
+            key = me.getKey(value);
+        }
+
+        if (me.containsKey(key)) {
+            return me.replace(key, value);
+        }
+
+        me.map[key] = value;
+        ++me.length;
+        if (me.hasListeners.add) {
+            me.fireEvent('add', me, key, value);
+        }
+        return value;
+    },
+
+    
+    replace: function(key, value) {
+        var me = this,
+            map = me.map,
+            old;
+
+        if (value === undefined) {
+            value = key;
+            key = me.getKey(value);
+        }
+
+        if (!me.containsKey(key)) {
+            me.add(key, value);
+        }
+        old = map[key];
+        map[key] = value;
+        if (me.hasListeners.replace) {
+            me.fireEvent('replace', me, key, value, old);
+        }
+        return value;
+    },
+
+    
+    remove: function(o) {
+        var key = this.findKey(o);
+        if (key !== undefined) {
+            return this.removeAtKey(key);
+        }
+        return false;
+    },
+
+    
+    removeAtKey: function(key) {
+        var me = this,
+            value;
+
+        if (me.containsKey(key)) {
+            value = me.map[key];
+            delete me.map[key];
+            --me.length;
+            if (me.hasListeners.remove) {
+                me.fireEvent('remove', me, key, value);
+            }
+            return true;
+        }
+        return false;
+    },
+
+    
+    get: function(key) {
+        return this.map[key];
+    },
+
+    
+    clear: function( initial) {
+        var me = this;
+        me.map = {};
+        me.length = 0;
+        if (initial !== true && me.hasListeners.clear) {
+            me.fireEvent('clear', me);
+        }
+        return me;
+    },
+
+    
+    containsKey: function(key) {
+        return this.map[key] !== undefined;
+    },
+
+    
+    contains: function(value) {
+        return this.containsKey(this.findKey(value));
+    },
+
+    
+    getKeys: function() {
+        return this.getArray(true);
+    },
+
+    
+    getValues: function() {
+        return this.getArray(false);
+    },
+
+    
+    getArray: function(isKey) {
+        var arr = [],
+            key,
+            map = this.map;
+        for (key in map) {
+            if (map.hasOwnProperty(key)) {
+                arr.push(isKey ? key: map[key]);
+            }
+        }
+        return arr;
+    },
+
+    
+    each: function(fn, scope) {
+        
+        var items = Ext.apply({}, this.map),
+            key,
+            length = this.length;
+
+        scope = scope || this;
+        for (key in items) {
+            if (items.hasOwnProperty(key)) {
+                if (fn.call(scope, key, items[key], length) === false) {
+                    break;
+                }
+            }
+        }
+        return this;
+    },
+
+    
+    clone: function() {
+        var hash = new this.self(),
+            map = this.map,
+            key;
+
+        hash.suspendEvents();
+        for (key in map) {
+            if (map.hasOwnProperty(key)) {
+                hash.add(key, map[key]);
+            }
+        }
+        hash.resumeEvents();
+        return hash;
+    },
+
+    
+    findKey: function(value) {
+        var key,
+            map = this.map;
+
+        for (key in map) {
+            if (map.hasOwnProperty(key) && map[key] === value) {
+                return key;
+            }
+        }
+        return undefined;
+    }
+});
+
+
+Ext.define('Ext.AbstractManager', {
+
+    
+
+    requires: ['Ext.util.HashMap'],
+
+    
+
+    typeName: 'type',
+
+    constructor: function(config) {
+        Ext.apply(this, config || {});
+
+        
+        this.all = new Ext.util.HashMap();
+
+        this.types = {};
+    },
+
+    
+    get : function(id) {
+        return this.all.get(id);
+    },
+
+    
+    register: function(item) {
+        this.all.add(item);
+    },
+
+    
+    unregister: function(item) {
+        this.all.remove(item);
+    },
+
+    
+    registerType : function(type, cls) {
+        this.types[type] = cls;
+        cls[this.typeName] = type;
+    },
+
+    
+    isRegistered : function(type){
+        return this.types[type] !== undefined;
+    },
+
+    
+    create: function(config, defaultType) {
+        var type        = config[this.typeName] || config.type || defaultType,
+            Constructor = this.types[type];
+
+
+        return new Constructor(config);
+    },
+
+    
+    onAvailable : function(id, fn, scope){
+        var all = this.all,
+            item,
+            callback;
+        
+        if (all.containsKey(id)) {
+            item = all.get(id);
+            fn.call(scope || item, item);
+        } else {
+            callback = function(map, key, item){
+                if (key == id) {
+                    fn.call(scope || item, item);
+                    all.un('add', callback);
+                }
+            }; 
+            all.on('add', callback);
+        }
+    },
+    
+    
+    each: function(fn, scope){
+        this.all.each(fn, scope || this);    
+    },
+    
+    
+    getCount: function(){
+        return this.all.getCount();
+    }
+});
+
+
+Ext.define('Ext.ComponentManager', {
+    extend: 'Ext.AbstractManager',
+    alternateClassName: 'Ext.ComponentMgr',
+    
+    singleton: true,
+    
+    typeName: 'xtype',
+    
+    
+    create: function(component, defaultType){
+        if (typeof component == 'string') {
+            return Ext.widget(component);
+        }
+        if (component.isComponent) {
+            return component;
+        }
+        return Ext.widget(component.xtype || defaultType, component);
+    },
+
+    registerType: function(type, cls) {
+        this.types[type] = cls;
+        cls[this.typeName] = type;
+        cls.prototype[this.typeName] = type;
+    }
+});
+
+
+Ext.define('Ext.ComponentQuery', {
+    singleton: true,
+    requires: ['Ext.ComponentManager']
+}, function() {
+
+    var cq = this,
+
+        
+        
+        filterFnPattern = [
+            'var r = [],',
+                'i = 0,',
+                'it = items,',
+                'l = it.length,',
+                'c;',
+            'for (; i < l; i++) {',
+                'c = it[i];',
+                'if (c.{0}) {',
+                   'r.push(c);',
+                '}',
+            '}',
+            'return r;'
+        ].join(''),
+
+        filterItems = function(items, operation) {
+            
+            
+            
+            return operation.method.apply(this, [ items ].concat(operation.args));
+        },
+
+        getItems = function(items, mode) {
+            var result = [],
+                i = 0,
+                length = items.length,
+                candidate,
+                deep = mode !== '>';
+                
+            for (; i < length; i++) {
+                candidate = items[i];
+                if (candidate.getRefItems) {
+                    result = result.concat(candidate.getRefItems(deep));
+                }
+            }
+            return result;
+        },
+
+        getAncestors = function(items) {
+            var result = [],
+                i = 0,
+                length = items.length,
+                candidate;
+            for (; i < length; i++) {
+                candidate = items[i];
+                while (!!(candidate = (candidate.ownerCt || candidate.floatParent))) {
+                    result.push(candidate);
+                }
+            }
+            return result;
+        },
+
+        
+        filterByXType = function(items, xtype, shallow) {
+            if (xtype === '*') {
+                return items.slice();
+            }
+            else {
+                var result = [],
+                    i = 0,
+                    length = items.length,
+                    candidate;
+                for (; i < length; i++) {
+                    candidate = items[i];
+                    if (candidate.isXType(xtype, shallow)) {
+                        result.push(candidate);
+                    }
+                }
+                return result;
+            }
+        },
+
+        
+        filterByClassName = function(items, className) {
+            var EA = Ext.Array,
+                result = [],
+                i = 0,
+                length = items.length,
+                candidate;
+            for (; i < length; i++) {
+                candidate = items[i];
+                if (candidate.hasCls(className)) {
+                    result.push(candidate);
+                }
+            }
+            return result;
+        },
+
+        
+        filterByAttribute = function(items, property, operator, value) {
+            var result = [],
+                i = 0,
+                length = items.length,
+                candidate;
+            for (; i < length; i++) {
+                candidate = items[i];
+                if (!value ? !!candidate[property] : (String(candidate[property]) === value)) {
+                    result.push(candidate);
+                }
+            }
+            return result;
+        },
+
+        
+        filterById = function(items, id) {
+            var result = [],
+                i = 0,
+                length = items.length,
+                candidate;
+            for (; i < length; i++) {
+                candidate = items[i];
+                if (candidate.getItemId() === id) {
+                    result.push(candidate);
+                }
+            }
+            return result;
+        },
+
+        
+        filterByPseudo = function(items, name, value) {
+            return cq.pseudos[name](items, value);
+        },
+
+        
+        
+        modeRe = /^(\s?([>\^])\s?|\s|$)/,
+
+        
+        tokenRe = /^(#)?([\w\-]+|\*)(?:\((true|false)\))?/,
+
+        matchers = [{
+            
+            re: /^\.([\w\-]+)(?:\((true|false)\))?/,
+            method: filterByXType
+        },{
+            
+            re: /^(?:[\[](?:@)?([\w\-]+)\s?(?:(=|.=)\s?['"]?(.*?)["']?)?[\]])/,
+            method: filterByAttribute
+        }, {
+            
+            re: /^#([\w\-]+)/,
+            method: filterById
+        }, {
+            
+            re: /^\:([\w\-]+)(?:\(((?:\{[^\}]+\})|(?:(?!\{)[^\s>\/]*?(?!\})))\))?/,
+            method: filterByPseudo
+        }, {
+            
+            re: /^(?:\{([^\}]+)\})/,
+            method: filterFnPattern
+        }];
+
+    
+    cq.Query = Ext.extend(Object, {
+        constructor: function(cfg) {
+            cfg = cfg || {};
+            Ext.apply(this, cfg);
+        },
+
+        
+        
+        
+        
+        
+        
+        
+        
+        execute : function(root) {
+            var operations = this.operations,
+                i = 0,
+                length = operations.length,
+                operation,
+                workingItems;
+
+            
+            if (!root) {
+                workingItems = Ext.ComponentManager.all.getArray();
+            }
+            
+            else if (Ext.isArray(root)) {
+                workingItems = root;
+            }
+            
+            else if (root.isMixedCollection) {
+                workingItems = root.items;
+            }
+
+            
+            
+            for (; i < length; i++) {
+                operation = operations[i];
+
+                
+                
+                
+                
+                
+                
+                if (operation.mode === '^') {
+                    workingItems = getAncestors(workingItems || [root]);
+                }
+                else if (operation.mode) {
+                    workingItems = getItems(workingItems || [root], operation.mode);
+                }
+                else {
+                    workingItems = filterItems(workingItems || getItems([root]), operation);
+                }
+
+                
+                
+                if (i === length -1) {
+                    return workingItems;
+                }
+            }
+            return [];
+        },
+
+        is: function(component) {
+            var operations = this.operations,
+                components = Ext.isArray(component) ? component : [component],
+                originalLength = components.length,
+                lastOperation = operations[operations.length-1],
+                ln, i;
+
+            components = filterItems(components, lastOperation);
+            if (components.length === originalLength) {
+                if (operations.length > 1) {
+                    for (i = 0, ln = components.length; i < ln; i++) {
+                        if (Ext.Array.indexOf(this.execute(), components[i]) === -1) {
+                            return false;
+                        }
+                    }
+                }
+                return true;
+            }
+            return false;
+        }
+    });
+
+    Ext.apply(this, {
+
+        
+        cache: {},
+
+        
+        pseudos: {
+            not: function(components, selector){
+                var CQ = Ext.ComponentQuery,
+                    i = 0,
+                    length = components.length,
+                    results = [],
+                    index = -1,
+                    component;
+                
+                for(; i < length; ++i) {
+                    component = components[i];
+                    if (!CQ.is(component, selector)) {
+                        results[++index] = component;
+                    }
+                }
+                return results;
+            },
+            first: function(components) {
+                var ret = [];
+                    
+                if (components.length > 0) {
+                    ret.push(components[0]);
+                }
+                return ret;       
+            },
+            last: function(components) {
+                var len = components.length,
+                    ret = [];
+                    
+                if (len > 0) {
+                    ret.push(components[len - 1]);
+                }
+                return ret;
+            }
+        },
+
+        
+        query: function(selector, root) {
+            var selectors = selector.split(','),
+                length = selectors.length,
+                i = 0,
+                results = [],
+                noDupResults = [], 
+                dupMatcher = {}, 
+                query, resultsLn, cmp;
+
+            for (; i < length; i++) {
+                selector = Ext.String.trim(selectors[i]);
+                query = this.cache[selector] || (this.cache[selector] = this.parse(selector));
+                results = results.concat(query.execute(root));
+            }
+
+            
+            
+            if (length > 1) {
+                resultsLn = results.length;
+                for (i = 0; i < resultsLn; i++) {
+                    cmp = results[i];
+                    if (!dupMatcher[cmp.id]) {
+                        noDupResults.push(cmp);
+                        dupMatcher[cmp.id] = true;
+                    }
+                }
+                results = noDupResults;
+            }
+            return results;
+        },
+
+        
+        is: function(component, selector) {
+            if (!selector) {
+                return true;
+            }
+            var selectors = selector.split(','),
+                length = selectors.length,
+                i = 0,
+                query;
+
+            for (; i < length; i++) {
+                selector = Ext.String.trim(selectors[i]);
+                query = this.cache[selector] || (this.cache[selector] = this.parse(selector));
+                if (query.is(component)) {
+                    return true;
+                }
+            }
+            return false;
+        },
+
+        parse: function(selector) {
+            var operations = [],
+                length = matchers.length,
+                lastSelector,
+                tokenMatch,
+                matchedChar,
+                modeMatch,
+                selectorMatch,
+                i, matcher, method;
+
+            
+            
+            
+            while (selector && lastSelector !== selector) {
+                lastSelector = selector;
+
+                
+                tokenMatch = selector.match(tokenRe);
+
+                if (tokenMatch) {
+                    matchedChar = tokenMatch[1];
+
+                    
+                    if (matchedChar === '#') {
+                        operations.push({
+                            method: filterById,
+                            args: [Ext.String.trim(tokenMatch[2])]
+                        });
+                    }
+                    
+                    
+                    else if (matchedChar === '.') {
+                        operations.push({
+                            method: filterByClassName,
+                            args: [Ext.String.trim(tokenMatch[2])]
+                        });
+                    }
+                    
+                    
+                    else {
+                        operations.push({
+                            method: filterByXType,
+                            args: [Ext.String.trim(tokenMatch[2]), Boolean(tokenMatch[3])]
+                        });
+                    }
+
+                    
+                    selector = selector.replace(tokenMatch[0], '');
+                }
+
+                
+                
+                
+                while (!(modeMatch = selector.match(modeRe))) {
+                    
+                    
+                    for (i = 0; selector && i < length; i++) {
+                        matcher = matchers[i];
+                        selectorMatch = selector.match(matcher.re);
+                        method = matcher.method;
+
+                        
+                        
+                        
+                        if (selectorMatch) {
+                            operations.push({
+                                method: Ext.isString(matcher.method)
+                                    
+                                    
+                                    
+                                    ? Ext.functionFactory('items', Ext.String.format.apply(Ext.String, [method].concat(selectorMatch.slice(1))))
+                                    : matcher.method,
+                                args: selectorMatch.slice(1)
+                            });
+                            selector = selector.replace(selectorMatch[0], '');
+                            break; 
+                        }
+                        
+                        if (i === (length - 1)) {
+                            Ext.Error.raise('Invalid ComponentQuery selector: "' + arguments[0] + '"');
+                        }
+                    }
+                }
+
+                
+                
+                
+                
+                if (modeMatch[1]) { 
+                    operations.push({
+                        mode: modeMatch[2]||modeMatch[1]
+                    });
+                    selector = selector.replace(modeMatch[0], '');
+                }
+            }
+
+            
+            
+            return new cq.Query({
+                operations: operations
+            });
+        }
+    });
+});
+
+
+
+
+Ext.define('Ext.util.ProtoElement', (function () {
+    var splitWords = Ext.String.splitWords,
+        toMap = Ext.Array.toMap;
+
+    return {
+        
+        isProtoEl: true,
+        
+        
+        clsProp: 'cls',
+
+        
+        styleProp: 'style',
+        
+        
+        removedProp: 'removed',
+
+        
+        styleIsText: false,
+
+        constructor: function (config) {
+            var me = this;
+
+            Ext.apply(me, config);
+
+            me.classList = splitWords(me.cls);
+            me.classMap = toMap(me.classList);
+            delete me.cls;
+
+            if (Ext.isFunction(me.style)) {
+                me.styleFn = me.style;
+                delete me.style;
+            } else if (typeof me.style == 'string') {
+                me.style = Ext.Element.parseStyles(me.style);
+            } else if (me.style) {
+                me.style = Ext.apply({}, me.style); 
+            }
+        },
+        
+        
+        flush: function(){
+            this.flushClassList = [];
+            this.removedClasses = {};
+            
+            delete this.style;
+        },
+
+        
+        addCls: function (cls) {
+            var me = this,
+                add = splitWords(cls),
+                length = add.length,
+                list = me.classList,
+                map = me.classMap,
+                flushList = me.flushClassList,
+                i = 0,
+                c;
+
+            for (; i < length; ++i) {
+                c = add[i];
+                if (!map[c]) {
+                    map[c] = true;
+                    list.push(c);
+                    if (flushList) {
+                        flushList.push(c);
+                        delete me.removedClasses[c];
+                    }
+                }
+            }
+
+            return me;
+        },
+
+        
+        hasCls: function (cls) {
+            return cls in this.classMap;
+        },
+
+        
+        removeCls: function (cls) {
+            var me = this,
+                list = me.classList,
+                newList = (me.classList = []),
+                remove = toMap(splitWords(cls)),
+                length = list.length,
+                map = me.classMap,
+                removedClasses = me.removedClasses,
+                i, c;
+
+            for (i = 0; i < length; ++i) {
+                c = list[i];
+                if (remove[c]) {
+                    if (removedClasses) {
+                        if (map[c]) {
+                            removedClasses[c] = true;
+                            Ext.Array.remove(me.flushClassList, c);
+                        }
+                    }
+                    delete map[c];
+                } else {
+                    newList.push(c);
+                }
+            }
+
+            return me;
+        },
+
+        
+        setStyle: function (prop, value) {
+            var me = this,
+                style = me.style || (me.style = {});
+
+            if (typeof prop == 'string') {
+                if (arguments.length === 1) {
+                    me.setStyle(Ext.Element.parseStyles(prop));
+                } else {
+                    style[prop] = value;
+                }
+            } else {
+                Ext.apply(style, prop);
+            }
+
+            return me;
+        },
+
+        
+        writeTo: function (to) {
+            var me = this,
+                classList = me.flushClassList || me.classList,
+                removedClasses = me.removedClasses,
+                style;
+
+            if (me.styleFn) {
+                style = Ext.apply({}, me.styleFn());
+                Ext.apply(style, me.style);
+            } else {
+                style = me.style;
+            }
+
+            to[me.clsProp] = classList.join(' ');
+
+            if (style) {
+                to[me.styleProp] = me.styleIsText ? Ext.DomHelper.generateStyles(style) : style;
+            }
+            
+            if (removedClasses) {
+                removedClasses = Ext.Object.getKeys(removedClasses);
+                if (removedClasses.length) {
+                    to[me.removedProp] = removedClasses.join(' ');
+                }
+            }
+
+            return to;
+        }
+    };
+}()));
+
+//@tag dom,core
+
+//@require util/Event.js
+
+//@define Ext.EventManager
+
+
+
+Ext.EventManager = new function() {
+    var EventManager = this,
+        doc = document,
+        win = window,
+        initExtCss = function() {
+            
+            var bd = doc.body || doc.getElementsByTagName('body')[0],
+                baseCSSPrefix = Ext.baseCSSPrefix,
+                cls = [baseCSSPrefix + 'body'],
+                htmlCls = [],
+                supportsLG = Ext.supports.CSS3LinearGradient,
+                supportsBR = Ext.supports.CSS3BorderRadius,
+                resetCls = [],
+                html,
+                resetElementSpec;
+
+            if (!bd) {
+                return false;
+            }
+
+            html = bd.parentNode;
+
+            function add (c) {
+                cls.push(baseCSSPrefix + c);
+            }
+
+            
+            if (Ext.isIE) {
+                add('ie');
+
+                
+                
+                
+                
+                
+                
+                
+                
+                
+                
+                
+                if (Ext.isIE6) {
+                    add('ie6');
+                } else { 
+                    add('ie7p');
+
+                    if (Ext.isIE7) {
+                        add('ie7');
+                    } else {
+                        add('ie8p');
+
+                        if (Ext.isIE8) {
+                            add('ie8');
+                        } else {
+                            add('ie9p');
+
+                            if (Ext.isIE9) {
+                                add('ie9');
+                            }
+                        }
+                    }
+                }
+
+                if (Ext.isIE6 || Ext.isIE7) {
+                    add('ie7m');
+                }
+                if (Ext.isIE6 || Ext.isIE7 || Ext.isIE8) {
+                    add('ie8m');
+                }
+                if (Ext.isIE7 || Ext.isIE8) {
+                    add('ie78');
+                }
+            }
+            if (Ext.isGecko) {
+                add('gecko');
+                if (Ext.isGecko3) {
+                    add('gecko3');
+                }
+                if (Ext.isGecko4) {
+                    add('gecko4');
+                }
+                if (Ext.isGecko5) {
+                    add('gecko5');
+                }
+            }
+            if (Ext.isOpera) {
+                add('opera');
+            }
+            if (Ext.isWebKit) {
+                add('webkit');
+            }
+            if (Ext.isSafari) {
+                add('safari');
+                if (Ext.isSafari2) {
+                    add('safari2');
+                }
+                if (Ext.isSafari3) {
+                    add('safari3');
+                }
+                if (Ext.isSafari4) {
+                    add('safari4');
+                }
+                if (Ext.isSafari5) {
+                    add('safari5');
+                }
+                if (Ext.isSafari5_0) {
+                    add('safari5_0')
+                }
+            }
+            if (Ext.isChrome) {
+                add('chrome');
+            }
+            if (Ext.isMac) {
+                add('mac');
+            }
+            if (Ext.isLinux) {
+                add('linux');
+            }
+            if (!supportsBR) {
+                add('nbr');
+            }
+            if (!supportsLG) {
+                add('nlg');
+            }
+
+            
+            
+            
+            if (Ext.scopeResetCSS) {
+
+                
+                resetElementSpec = Ext.resetElementSpec = {
+                    cls: baseCSSPrefix + 'reset'
+                };
+                
+                if (!supportsLG) {
+                    resetCls.push(baseCSSPrefix + 'nlg');
+                }
+                
+                if (!supportsBR) {
+                    resetCls.push(baseCSSPrefix + 'nbr');
+                }
+                
+                if (resetCls.length) {                    
+                    resetElementSpec.cn = {
+                        cls: resetCls.join(' ')
+                    };
+                }
+                
+                Ext.resetElement = Ext.getBody().createChild(resetElementSpec);
+                if (resetCls.length) {
+                    Ext.resetElement = Ext.get(Ext.resetElement.dom.firstChild);
+                }
+            }
+            
+            else {
+                Ext.resetElement = Ext.getBody();
+                add('reset');
+            }
+
+            
+            if (html) {
+                if (Ext.isStrict && (Ext.isIE6 || Ext.isIE7)) {
+                    Ext.isBorderBox = false;
+                }
+                else {
+                    Ext.isBorderBox = true;
+                }
+
+                if(Ext.isBorderBox) {
+                    htmlCls.push(baseCSSPrefix + 'border-box');
+                }
+                if (Ext.isStrict) {
+                    htmlCls.push(baseCSSPrefix + 'strict');
+                } else {
+                    htmlCls.push(baseCSSPrefix + 'quirks');
+                }
+                Ext.fly(html, '_internal').addCls(htmlCls);
+            }
+
+            Ext.fly(bd, '_internal').addCls(cls);
+            return true;
+        };
+
+    Ext.apply(EventManager, {
+        
+        hasBoundOnReady: false,
+
+        
+        hasFiredReady: false,
+
+        
+        deferReadyEvent : 1,
+
+        
+        onReadyChain : [],
+
+        
+        readyEvent:
+            (function () {
+                var event = new Ext.util.Event();
+                event.fire = function () {
+                    Ext._beforeReadyTime = Ext._beforeReadyTime || new Date().getTime();
+                    event.self.prototype.fire.apply(event, arguments);
+                    Ext._afterReadytime = new Date().getTime();
+                };
+                return event;
+            }()),
+
+        
+        idleEvent: new Ext.util.Event(),
+
+        
+        isReadyPaused: function(){
+            return (/[?&]ext-pauseReadyFire\b/i.test(location.search) && !Ext._continueFireReady);
+        },
+
+        
+        bindReadyEvent: function() {
+            if (EventManager.hasBoundOnReady) {
+                return;
+            }
+
+            
+            if ( doc.readyState == 'complete'  ) {  
+                EventManager.onReadyEvent({
+                    type: doc.readyState || 'body'
+                });
+            } else {
+                document.addEventListener('DOMContentLoaded', EventManager.onReadyEvent, false);
+                window.addEventListener('load', EventManager.onReadyEvent, false);
+                EventManager.hasBoundOnReady = true;
+            }
+        },
+
+        onReadyEvent : function(e) {
+            if (e && e.type) {
+                EventManager.onReadyChain.push(e.type);
+            }
+
+            if (EventManager.hasBoundOnReady) {
+                document.removeEventListener('DOMContentLoaded', EventManager.onReadyEvent, false);
+                window.removeEventListener('load', EventManager.onReadyEvent, false);
+            }
+
+            if (!Ext.isReady) {
+                EventManager.fireDocReady();
+            }
+        },
+
+        
+        fireDocReady: function() {
+            if (!Ext.isReady) {
+                Ext._readyTime = new Date().getTime();
+                Ext.isReady = true;
+
+                Ext.supports.init();
+                EventManager.onWindowUnload();
+                EventManager.readyEvent.onReadyChain = EventManager.onReadyChain;    
+
+                if (Ext.isNumber(EventManager.deferReadyEvent)) {
+                    Ext.Function.defer(EventManager.fireReadyEvent, EventManager.deferReadyEvent);
+                    EventManager.hasDocReadyTimer = true;
+                } else {
+                    EventManager.fireReadyEvent();
+                }
+            }
+        },
+
+        
+        fireReadyEvent: function(){
+            var readyEvent = EventManager.readyEvent;
+
+            
+            
+            EventManager.hasDocReadyTimer = false;
+            EventManager.isFiring = true;
+
+            
+            
+            
+            while (readyEvent.listeners.length && !EventManager.isReadyPaused()) {
+                readyEvent.fire();
+            }
+            EventManager.isFiring = false;
+            EventManager.hasFiredReady = true;
+        },
+
+        
+        onDocumentReady: function(fn, scope, options) {
+            options = options || {};
+            
+            options.single = true;
+            EventManager.readyEvent.addListener(fn, scope, options);
+
+            
+            
+            if (!(EventManager.isFiring || EventManager.hasDocReadyTimer)) {
+                if (Ext.isReady) {
+                    EventManager.fireReadyEvent();
+                } else {
+                    EventManager.bindReadyEvent();
+                }
+            }
+        },
+
+        
+
+        
+        stoppedMouseDownEvent: new Ext.util.Event(),
+
+        
+        propRe: /^(?:scope|delay|buffer|single|stopEvent|preventDefault|stopPropagation|normalized|args|delegate|freezeEvent)$/,
+
+        
+        getId : function(element) {
+            var id;
+
+            element = Ext.getDom(element);
+
+            if (element === doc || element === win) {
+                id = element === doc ? Ext.documentId : Ext.windowId;
+            }
+            else {
+                id = Ext.id(element);
+            }
+
+            if (!Ext.cache[id]) {
+                Ext.addCacheEntry(id, null, element);
+            }
+
+            return id;
+        },
+
+        
+        prepareListenerConfig: function(element, config, isRemove) {
+            var propRe = EventManager.propRe,
+                key, value, args;
+
+            
+            for (key in config) {
+                if (config.hasOwnProperty(key)) {
+                    
+                    if (!propRe.test(key)) {
+                        value = config[key];
+                        
+                        
+                        if (typeof value == 'function') {
+                            
+                            args = [element, key, value, config.scope, config];
+                        } else {
+                            
+                            args = [element, key, value.fn, value.scope, value];
+                        }
+
+                        if (isRemove) {
+                            EventManager.removeListener.apply(EventManager, args);
+                        } else {
+                            EventManager.addListener.apply(EventManager, args);
+                        }
+                    }
+                }
+            }
+        },
+
+        mouseEnterLeaveRe: /mouseenter|mouseleave/,
+
+        
+        normalizeEvent: function(eventName, fn) {
+            if (EventManager.mouseEnterLeaveRe.test(eventName) && !Ext.supports.MouseEnterLeave) {
+                if (fn) {
+                    fn = Ext.Function.createInterceptor(fn, EventManager.contains);
+                }
+                eventName = eventName == 'mouseenter' ? 'mouseover' : 'mouseout';
+            } else if (eventName == 'mousewheel' && !Ext.supports.MouseWheel && !Ext.isOpera) {
+                eventName = 'DOMMouseScroll';
+            }
+            return {
+                eventName: eventName,
+                fn: fn
+            };
+        },
+
+        
+        contains: function(event) {
+            var parent = event.browserEvent.currentTarget,
+                child = EventManager.getRelatedTarget(event);
+
+            if (parent && parent.firstChild) {
+                while (child) {
+                    if (child === parent) {
+                        return false;
+                    }
+                    child = child.parentNode;
+                    if (child && (child.nodeType != 1)) {
+                        child = null;
+                    }
+                }
+            }
+            return true;
+        },
+
+        
+        addListener: function(element, eventName, fn, scope, options) {
+            
+            if (typeof eventName !== 'string') {
+                EventManager.prepareListenerConfig(element, eventName);
+                return;
+            }
+
+            var dom = element.dom || Ext.getDom(element),
+                bind, wrap;
+
+
+            
+            options = options || {};
+
+            bind = EventManager.normalizeEvent(eventName, fn);
+            wrap = EventManager.createListenerWrap(dom, eventName, bind.fn, scope, options);
+
+            if (dom.attachEvent) {
+                dom.attachEvent('on' + bind.eventName, wrap);
+            } else {
+                dom.addEventListener(bind.eventName, wrap, options.capture || false);
+            }
+
+            if (dom == doc && eventName == 'mousedown') {
+                EventManager.stoppedMouseDownEvent.addListener(wrap);
+            }
+
+            
+            EventManager.getEventListenerCache(element.dom ? element : dom, eventName).push({
+                fn: fn,
+                wrap: wrap,
+                scope: scope
+            });
+        },
+
+        
+        removeListener : function(element, eventName, fn, scope) {
+            
+            if (typeof eventName !== 'string') {
+                EventManager.prepareListenerConfig(element, eventName, true);
+                return;
+            }
+
+            var dom = Ext.getDom(element),
+                el = element.dom ? element : Ext.get(dom),
+                cache = EventManager.getEventListenerCache(el, eventName),
+                bindName = EventManager.normalizeEvent(eventName).eventName,
+                i = cache.length, j,
+                listener, wrap, tasks;
+
+
+            while (i--) {
+                listener = cache[i];
+
+                if (listener && (!fn || listener.fn == fn) && (!scope || listener.scope === scope)) {
+                    wrap = listener.wrap;
+
+                    
+                    if (wrap.task) {
+                        clearTimeout(wrap.task);
+                        delete wrap.task;
+                    }
+
+                    
+                    j = wrap.tasks && wrap.tasks.length;
+                    if (j) {
+                        while (j--) {
+                            clearTimeout(wrap.tasks[j]);
+                        }
+                        delete wrap.tasks;
+                    }
+
+                    if (dom.detachEvent) {
+                        dom.detachEvent('on' + bindName, wrap);
+                    } else {
+                        dom.removeEventListener(bindName, wrap, false);
+                    }
+
+                    if (wrap && dom == doc && eventName == 'mousedown') {
+                        EventManager.stoppedMouseDownEvent.removeListener(wrap);
+                    }
+
+                    
+                    Ext.Array.erase(cache, i, 1);
+                }
+            }
+        },
+
+        
+        removeAll : function(element) {
+            var el = element.dom ? element : Ext.get(element),
+                cache, events, eventName;
+
+            if (!el) {
+                return;
+            }
+            cache = (el.$cache || el.getCache());
+            events = cache.events;
+
+            for (eventName in events) {
+                if (events.hasOwnProperty(eventName)) {
+                    EventManager.removeListener(el, eventName);
+                }
+            }
+            cache.events = {};
+        },
+
+        
+        purgeElement : function(element, eventName) {
+            var dom = Ext.getDom(element),
+                i = 0, len;
+
+            if (eventName) {
+                EventManager.removeListener(element, eventName);
+            }
+            else {
+                EventManager.removeAll(element);
+            }
+
+            if (dom && dom.childNodes) {
+                for (len = element.childNodes.length; i < len; i++) {
+                    EventManager.purgeElement(element.childNodes[i], eventName);
+                }
+            }
+        },
+
+        
+        createListenerWrap : function(dom, ename, fn, scope, options) {
+            options = options || {};
+
+            var f, gen, escapeRx = /\\/g, wrap = function(e, args) {
+                
+                if (!gen) {
+                    f = ['if(!' + Ext.name + ') {return;}'];
+
+                    if(options.buffer || options.delay || options.freezeEvent) {
+                        f.push('e = new X.EventObjectImpl(e, ' + (options.freezeEvent ? 'true' : 'false' ) + ');');
+                    } else {
+                        f.push('e = X.EventObject.setEvent(e);');
+                    }
+
+                    if (options.delegate) {
+                        
+                        
+                        f.push('var result, t = e.getTarget("' + (options.delegate + '').replace(escapeRx, '\\\\') + '", this);');
+                        f.push('if(!t) {return;}');
+                    } else {
+                        f.push('var t = e.target, result;');
+                    }
+
+                    if (options.target) {
+                        f.push('if(e.target !== options.target) {return;}');
+                    }
+
+                    if(options.stopEvent) {
+                        f.push('e.stopEvent();');
+                    } else {
+                        if(options.preventDefault) {
+                            f.push('e.preventDefault();');
+                        }
+                        if(options.stopPropagation) {
+                            f.push('e.stopPropagation();');
+                        }
+                    }
+
+                    if(options.normalized === false) {
+                        f.push('e = e.browserEvent;');
+                    }
+
+                    if(options.buffer) {
+                        f.push('(wrap.task && clearTimeout(wrap.task));');
+                        f.push('wrap.task = setTimeout(function() {');
+                    }
+
+                    if(options.delay) {
+                        f.push('wrap.tasks = wrap.tasks || [];');
+                        f.push('wrap.tasks.push(setTimeout(function() {');
+                    }
+
+                    
+                    f.push('result = fn.call(scope || dom, e, t, options);');
+
+                    if(options.single) {
+                        f.push('evtMgr.removeListener(dom, ename, fn, scope);');
+                    }
+
+                    
+                    
+                    if (ename !== 'mousemove') {
+                        f.push('if (evtMgr.idleEvent.listeners.length) {');
+                        f.push('evtMgr.idleEvent.fire();');
+                        f.push('}');
+                    }
+
+                    if(options.delay) {
+                        f.push('}, ' + options.delay + '));');
+                    }
+
+                    if(options.buffer) {
+                        f.push('}, ' + options.buffer + ');');
+                    }
+                    f.push('return result;')
+
+                    gen = Ext.cacheableFunctionFactory('e', 'options', 'fn', 'scope', 'ename', 'dom', 'wrap', 'args', 'X', 'evtMgr', f.join('\n'));
+                }
+
+                return gen.call(dom, e, options, fn, scope, ename, dom, wrap, args, Ext, EventManager);
+            };
+            return wrap;
+        },
+
+        
+        getEventListenerCache : function(element, eventName) {
+            var elementCache, eventCache;
+            if (!element) {
+                return [];
+            }
+
+            if (element.$cache) {
+                elementCache = element.$cache;
+            } else {
+                
+                elementCache = Ext.cache[EventManager.getId(element)];
+            }
+            eventCache = elementCache.events || (elementCache.events = {});
+
+            return eventCache[eventName] || (eventCache[eventName] = []);
+        },
+
+        
+        mouseLeaveRe: /(mouseout|mouseleave)/,
+        mouseEnterRe: /(mouseover|mouseenter)/,
+
+        
+        stopEvent: function(event) {
+            EventManager.stopPropagation(event);
+            EventManager.preventDefault(event);
+        },
+
+        
+        stopPropagation: function(event) {
+            event = event.browserEvent || event;
+            if (event.stopPropagation) {
+                event.stopPropagation();
+            } else {
+                event.cancelBubble = true;
+            }
+        },
+
+        
+        preventDefault: function(event) {
+            event = event.browserEvent || event;
+            if (event.preventDefault) {
+                event.preventDefault();
+            } else {
+                event.returnValue = false;
+                
+                try {
+                  
+                  if (event.ctrlKey || event.keyCode > 111 && event.keyCode < 124) {
+                      event.keyCode = -1;
+                  }
+                } catch (e) {
+                    
+                }
+            }
+        },
+
+        
+        getRelatedTarget: function(event) {
+            event = event.browserEvent || event;
+            var target = event.relatedTarget;
+            if (!target) {
+                if (EventManager.mouseLeaveRe.test(event.type)) {
+                    target = event.toElement;
+                } else if (EventManager.mouseEnterRe.test(event.type)) {
+                    target = event.fromElement;
+                }
+            }
+            return EventManager.resolveTextNode(target);
+        },
+
+        
+        getPageX: function(event) {
+            return EventManager.getPageXY(event)[0];
+        },
+
+        
+        getPageY: function(event) {
+            return EventManager.getPageXY(event)[1];
+        },
+
+        
+        getPageXY: function(event) {
+            event = event.browserEvent || event;
+            var x = event.pageX,
+                y = event.pageY,
+                docEl = doc.documentElement,
+                body = doc.body;
+
+            
+            if (!x && x !== 0) {
+                x = event.clientX + (docEl && docEl.scrollLeft || body && body.scrollLeft || 0) - (docEl && docEl.clientLeft || body && body.clientLeft || 0);
+                y = event.clientY + (docEl && docEl.scrollTop  || body && body.scrollTop  || 0) - (docEl && docEl.clientTop  || body && body.clientTop  || 0);
+            }
+            return [x, y];
+        },
+
+        
+        getTarget: function(event) {
+            event = event.browserEvent || event;
+            return EventManager.resolveTextNode(event.target || event.srcElement);
+        },
+
+        
+        
+        
+        
+        resolveTextNode: Ext.isGecko ?
+            function(node) {
+                if (!node) {
+                    return;
+                }
+                
+                var s = HTMLElement.prototype.toString.call(node);
+                if (s == '[xpconnect wrapped native prototype]' || s == '[object XULElement]') {
+                    return;
+                }
+                    return node.nodeType == 3 ? node.parentNode: node;
+                }: function(node) {
+                    return node && node.nodeType == 3 ? node.parentNode: node;
+                },
+
+        
+
+        
+        curWidth: 0,
+        curHeight: 0,
+
+        
+        onWindowResize: function(fn, scope, options) {
+            var resize = EventManager.resizeEvent;
+
+            if (!resize) {
+                EventManager.resizeEvent = resize = new Ext.util.Event();
+                EventManager.on(win, 'resize', EventManager.fireResize, null, {buffer: 100});
+            }
+            resize.addListener(fn, scope, options);
+        },
+
+        
+        fireResize: function() {
+            var w = Ext.Element.getViewWidth(),
+                h = Ext.Element.getViewHeight();
+
+             
+             if (EventManager.curHeight != h || EventManager.curWidth != w) {
+                 EventManager.curHeight = h;
+                 EventManager.curWidth = w;
+                 EventManager.resizeEvent.fire(w, h);
+             }
+        },
+
+        
+        removeResizeListener: function(fn, scope) {
+            var resize = EventManager.resizeEvent;
+            if (resize) {
+                resize.removeListener(fn, scope);
+            }
+        },
+
+        
+        onWindowUnload: function(fn, scope, options) {
+            var unload = EventManager.unloadEvent;
+
+            if (!unload) {
+                EventManager.unloadEvent = unload = new Ext.util.Event();
+                EventManager.addListener(win, 'unload', EventManager.fireUnload);
+            }
+            if (fn) {
+                unload.addListener(fn, scope, options);
+            }
+        },
+
+        
+        fireUnload: function() {
+            
+            try {
+                
+                doc = win = undefined;
+
+                var gridviews, i, ln,
+                    el, cache;
+
+                EventManager.unloadEvent.fire();
+                
+                if (Ext.isGecko3) {
+                    gridviews = Ext.ComponentQuery.query('gridview');
+                    i = 0;
+                    ln = gridviews.length;
+                    for (; i < ln; i++) {
+                        gridviews[i].scrollToTop();
+                    }
+                }
+                
+                cache = Ext.cache;
+
+                for (el in cache) {
+                    if (cache.hasOwnProperty(el)) {
+                        EventManager.removeAll(el);
+                    }
+                }
+            } catch(e) {
+            }
+        },
+
+        
+        removeUnloadListener: function(fn, scope) {
+            var unload = EventManager.unloadEvent;
+            if (unload) {
+                unload.removeListener(fn, scope);
+            }
+        },
+
+        
+        useKeyDown: Ext.isWebKit ?
+                       parseInt(navigator.userAgent.match(/AppleWebKit\/(\d+)/)[1], 10) >= 525 :
+                       !((Ext.isGecko && !Ext.isWindows) || Ext.isOpera),
+
+        
+        getKeyEvent: function() {
+            return EventManager.useKeyDown ? 'keydown' : 'keypress';
+        }
+    });
+
+    
+    if(!('addEventListener' in document) && document.attachEvent) {
+        Ext.apply( EventManager, {
+            
+
+            
+            pollScroll : function() {
+                var scrollable = true;
+
+                try {
+                    document.documentElement.doScroll('left');
+                } catch(e) {
+                    scrollable = false;
+                }
+
+                
+                if (scrollable && document.body) {
+                    EventManager.onReadyEvent({
+                        type:'doScroll'
+                    });
+                } else {
+                    
+                    EventManager.scrollTimeout = setTimeout(EventManager.pollScroll, 20);
+                }
+
+                return scrollable;
+            },
+
+            
+            scrollTimeout: null,
+
+            
+            readyStatesRe  : /complete/i,
+
+            
+            checkReadyState: function() {
+                var state = document.readyState;
+
+                if (EventManager.readyStatesRe.test(state)) {
+                    EventManager.onReadyEvent({
+                        type: state
+                    });
+                }
+            },
+
+            bindReadyEvent: function() {
+                var topContext = true;
+
+                if (EventManager.hasBoundOnReady) {
+                    return;
+                }
+
+                
+                try {
+                    topContext = window.frameElement === undefined;
+                } catch(e) {
+                    
+                    
+                    topContext = false;
+                }
+
+                if (!topContext || !doc.documentElement.doScroll) {
+                    EventManager.pollScroll = Ext.emptyFn;   
+                }
+
+                
+                if (EventManager.pollScroll() === true) {
+                    return;
+                }
+
+                
+                if (doc.readyState == 'complete' )  {
+                    EventManager.onReadyEvent({type: 'already ' + (doc.readyState || 'body') });
+                } else {
+                    doc.attachEvent('onreadystatechange', EventManager.checkReadyState);
+                    window.attachEvent('onload', EventManager.onReadyEvent);
+                    EventManager.hasBoundOnReady = true;
+                }
+            },
+
+            onReadyEvent : function(e) {
+                if (e && e.type) {
+                    EventManager.onReadyChain.push(e.type);
+                }
+
+                if (EventManager.hasBoundOnReady) {
+                    document.detachEvent('onreadystatechange', EventManager.checkReadyState);
+                    window.detachEvent('onload', EventManager.onReadyEvent);
+                }
+
+                if (Ext.isNumber(EventManager.scrollTimeout)) {
+                    clearTimeout(EventManager.scrollTimeout);
+                    delete EventManager.scrollTimeout;
+                }
+
+                if (!Ext.isReady) {
+                    EventManager.fireDocReady();
+                }
+            },
+
+            
+            onReadyChain : []
+        });
+    }
+
+
+    
+    Ext.onReady = function(fn, scope, options) {
+        Ext.Loader.onReady(fn, scope, true, options);
+    };
+
+    
+    Ext.onDocumentReady = EventManager.onDocumentReady;
+
+    
+    EventManager.on = EventManager.addListener;
+
+    
+    EventManager.un = EventManager.removeListener;
+
+    Ext.onReady(initExtCss);
+};
+
+//@tag dom,core
+
+//@require EventManager.js
+
+//@define Ext.EventObject
+
+
+
+Ext.define('Ext.EventObjectImpl', {
+    uses: ['Ext.util.Point'],
+
+    
+    BACKSPACE: 8,
+    
+    TAB: 9,
+    
+    NUM_CENTER: 12,
+    
+    ENTER: 13,
+    
+    RETURN: 13,
+    
+    SHIFT: 16,
+    
+    CTRL: 17,
+    
+    ALT: 18,
+    
+    PAUSE: 19,
+    
+    CAPS_LOCK: 20,
+    
+    ESC: 27,
+    
+    SPACE: 32,
+    
+    PAGE_UP: 33,
+    
+    PAGE_DOWN: 34,
+    
+    END: 35,
+    
+    HOME: 36,
+    
+    LEFT: 37,
+    
+    UP: 38,
+    
+    RIGHT: 39,
+    
+    DOWN: 40,
+    
+    PRINT_SCREEN: 44,
+    
+    INSERT: 45,
+    
+    DELETE: 46,
+    
+    ZERO: 48,
+    
+    ONE: 49,
+    
+    TWO: 50,
+    
+    THREE: 51,
+    
+    FOUR: 52,
+    
+    FIVE: 53,
+    
+    SIX: 54,
+    
+    SEVEN: 55,
+    
+    EIGHT: 56,
+    
+    NINE: 57,
+    
+    A: 65,
+    
+    B: 66,
+    
+    C: 67,
+    
+    D: 68,
+    
+    E: 69,
+    
+    F: 70,
+    
+    G: 71,
+    
+    H: 72,
+    
+    I: 73,
+    
+    J: 74,
+    
+    K: 75,
+    
+    L: 76,
+    
+    M: 77,
+    
+    N: 78,
+    
+    O: 79,
+    
+    P: 80,
+    
+    Q: 81,
+    
+    R: 82,
+    
+    S: 83,
+    
+    T: 84,
+    
+    U: 85,
+    
+    V: 86,
+    
+    W: 87,
+    
+    X: 88,
+    
+    Y: 89,
+    
+    Z: 90,
+    
+    CONTEXT_MENU: 93,
+    
+    NUM_ZERO: 96,
+    
+    NUM_ONE: 97,
+    
+    NUM_TWO: 98,
+    
+    NUM_THREE: 99,
+    
+    NUM_FOUR: 100,
+    
+    NUM_FIVE: 101,
+    
+    NUM_SIX: 102,
+    
+    NUM_SEVEN: 103,
+    
+    NUM_EIGHT: 104,
+    
+    NUM_NINE: 105,
+    
+    NUM_MULTIPLY: 106,
+    
+    NUM_PLUS: 107,
+    
+    NUM_MINUS: 109,
+    
+    NUM_PERIOD: 110,
+    
+    NUM_DIVISION: 111,
+    
+    F1: 112,
+    
+    F2: 113,
+    
+    F3: 114,
+    
+    F4: 115,
+    
+    F5: 116,
+    
+    F6: 117,
+    
+    F7: 118,
+    
+    F8: 119,
+    
+    F9: 120,
+    
+    F10: 121,
+    
+    F11: 122,
+    
+    F12: 123,
+    
+    WHEEL_SCALE: (function () {
+        var scale;
+
+        if (Ext.isGecko) {
+            
+            scale = 3;
+        } else if (Ext.isMac) {
+            
+            
+            
+
+            if (Ext.isSafari && Ext.webKitVersion >= 532.0) {
+                
+                
+                
+                
+                
+                
+                scale = 120;
+            } else {
+                
+                
+                scale = 12;
+            }
+
+            
+            
+            
+            
+            scale *= 3;
+        } else {
+            
+            scale = 120;
+        }
+
+        return scale;
+    }()),
+
+    
+    clickRe: /(dbl)?click/,
+    
+    safariKeys: {
+        3: 13, 
+        63234: 37, 
+        63235: 39, 
+        63232: 38, 
+        63233: 40, 
+        63276: 33, 
+        63277: 34, 
+        63272: 46, 
+        63273: 36, 
+        63275: 35 
+    },
+    
+    btnMap: Ext.isIE ? {
+        1: 0,
+        4: 1,
+        2: 2
+    } : {
+        0: 0,
+        1: 1,
+        2: 2
+    },
+    
+    
+    
+    
+
+    constructor: function(event, freezeEvent){
+        if (event) {
+            this.setEvent(event.browserEvent || event, freezeEvent);
+        }
+    },
+
+    setEvent: function(event, freezeEvent){
+        var me = this, button, options;
+
+        if (event == me || (event && event.browserEvent)) { 
+            return event;
+        }
+        me.browserEvent = event;
+        if (event) {
+            
+            button = event.button ? me.btnMap[event.button] : (event.which ? event.which - 1 : -1);
+            if (me.clickRe.test(event.type) && button == -1) {
+                button = 0;
+            }
+            options = {
+                type: event.type,
+                button: button,
+                shiftKey: event.shiftKey,
+                
+                ctrlKey: event.ctrlKey || event.metaKey || false,
+                altKey: event.altKey,
+                
+                keyCode: event.keyCode,
+                charCode: event.charCode,
+                
+                target: Ext.EventManager.getTarget(event),
+                relatedTarget: Ext.EventManager.getRelatedTarget(event),
+                currentTarget: event.currentTarget,
+                xy: (freezeEvent ? me.getXY() : null)
+            };
+        } else {
+            options = {
+                button: -1,
+                shiftKey: false,
+                ctrlKey: false,
+                altKey: false,
+                keyCode: 0,
+                charCode: 0,
+                target: null,
+                xy: [0, 0]
+            };
+        }
+        Ext.apply(me, options);
+        return me;
+    },
+
+    
+    stopEvent: function(){
+        this.stopPropagation();
+        this.preventDefault();
+    },
+
+    
+    preventDefault: function(){
+        if (this.browserEvent) {
+            Ext.EventManager.preventDefault(this.browserEvent);
+        }
+    },
+
+    
+    stopPropagation: function(){
+        var browserEvent = this.browserEvent;
+
+        if (browserEvent) {
+            if (browserEvent.type == 'mousedown') {
+                Ext.EventManager.stoppedMouseDownEvent.fire(this);
+            }
+            Ext.EventManager.stopPropagation(browserEvent);
+        }
+    },
+
+    
+    getCharCode: function(){
+        return this.charCode || this.keyCode;
+    },
+
+    
+    getKey: function(){
+        return this.normalizeKey(this.keyCode || this.charCode);
+    },
+
+    
+    normalizeKey: function(key){
+        
+        return Ext.isWebKit ? (this.safariKeys[key] || key) : key;
+    },
+
+    
+    getPageX: function(){
+        return this.getX();
+    },
+
+    
+    getPageY: function(){
+        return this.getY();
+    },
+
+    
+    getX: function() {
+        return this.getXY()[0];
+    },
+
+    
+    getY: function() {
+        return this.getXY()[1];
+    },
+
+    
+    getXY: function() {
+        if (!this.xy) {
+            
+            this.xy = Ext.EventManager.getPageXY(this.browserEvent);
+        }
+        return this.xy;
+    },
+
+    
+    getTarget : function(selector, maxDepth, returnEl){
+        if (selector) {
+            return Ext.fly(this.target).findParent(selector, maxDepth, returnEl);
+        }
+        return returnEl ? Ext.get(this.target) : this.target;
+    },
+
+    
+    getRelatedTarget : function(selector, maxDepth, returnEl){
+        if (selector) {
+            return Ext.fly(this.relatedTarget).findParent(selector, maxDepth, returnEl);
+        }
+        return returnEl ? Ext.get(this.relatedTarget) : this.relatedTarget;
+    },
+
+    
+    correctWheelDelta : function (delta) {
+        var scale = this.WHEEL_SCALE,
+            ret = Math.round(delta / scale);
+
+        if (!ret && delta) {
+            ret = (delta < 0) ? -1 : 1; 
+        }
+
+        return ret;
+    },
+
+    
+    getWheelDeltas : function () {
+        var me = this,
+            event = me.browserEvent,
+            dx = 0, dy = 0; 
+
+        if (Ext.isDefined(event.wheelDeltaX)) { 
+            dx = event.wheelDeltaX;
+            dy = event.wheelDeltaY;
+        } else if (event.wheelDelta) { 
+            dy = event.wheelDelta;
+        } else if (event.detail) { 
+            dy = -event.detail; 
+
+            
+            
+            if (dy > 100) {
+                dy = 3;
+            } else if (dy < -100) {
+                dy = -3;
+            }
+
+            
+            
+            if (Ext.isDefined(event.axis) && event.axis === event.HORIZONTAL_AXIS) {
+                dx = dy;
+                dy = 0;
+            }
+        }
+
+        return {
+            x: me.correctWheelDelta(dx),
+            y: me.correctWheelDelta(dy)
+        };
+    },
+
+    
+    getWheelDelta : function(){
+        var deltas = this.getWheelDeltas();
+
+        return deltas.y;
+    },
+
+    
+    within : function(el, related, allowEl){
+        if(el){
+            var t = related ? this.getRelatedTarget() : this.getTarget(),
+                result;
+
+            if (t) {
+                result = Ext.fly(el).contains(t);
+                if (!result && allowEl) {
+                    result = t == Ext.getDom(el);
+                }
+                return result;
+            }
+        }
+        return false;
+    },
+
+    
+    isNavKeyPress : function(){
+        var me = this,
+            k = this.normalizeKey(me.keyCode);
+
+       return (k >= 33 && k <= 40) ||  
+       k == me.RETURN ||
+       k == me.TAB ||
+       k == me.ESC;
+    },
+
+    
+    isSpecialKey : function(){
+        var k = this.normalizeKey(this.keyCode);
+        return (this.type == 'keypress' && this.ctrlKey) ||
+        this.isNavKeyPress() ||
+        (k == this.BACKSPACE) || 
+        (k >= 16 && k <= 20) || 
+        (k >= 44 && k <= 46);   
+    },
+
+    
+    getPoint : function(){
+        var xy = this.getXY();
+        return new Ext.util.Point(xy[0], xy[1]);
+    },
+
+   
+    hasModifier : function(){
+        return this.ctrlKey || this.altKey || this.shiftKey || this.metaKey;
+    },
+
+    
+    injectEvent: (function () {
+        var API,
+            dispatchers = {}, 
+            crazyIEButtons;
+
+        
+
+        
+        
+
+        if (!Ext.isIE && document.createEvent) { 
+            API = {
+                createHtmlEvent: function (doc, type, bubbles, cancelable) {
+                    var event = doc.createEvent('HTMLEvents');
+
+                    event.initEvent(type, bubbles, cancelable);
+                    return event;
+                },
+
+                createMouseEvent: function (doc, type, bubbles, cancelable, detail,
+                                            clientX, clientY, ctrlKey, altKey, shiftKey, metaKey,
+                                            button, relatedTarget) {
+                    var event = doc.createEvent('MouseEvents'),
+                        view = doc.defaultView || window;
+
+                    if (event.initMouseEvent) {
+                        event.initMouseEvent(type, bubbles, cancelable, view, detail,
+                                    clientX, clientY, clientX, clientY, ctrlKey, altKey,
+                                    shiftKey, metaKey, button, relatedTarget);
+                    } else { 
+                        event = doc.createEvent('UIEvents');
+                        event.initEvent(type, bubbles, cancelable);
+                        event.view = view;
+                        event.detail = detail;
+                        event.screenX = clientX;
+                        event.screenY = clientY;
+                        event.clientX = clientX;
+                        event.clientY = clientY;
+                        event.ctrlKey = ctrlKey;
+                        event.altKey = altKey;
+                        event.metaKey = metaKey;
+                        event.shiftKey = shiftKey;
+                        event.button = button;
+                        event.relatedTarget = relatedTarget;
+                    }
+
+                    return event;
+                },
+
+                createUIEvent: function (doc, type, bubbles, cancelable, detail) {
+                    var event = doc.createEvent('UIEvents'),
+                        view = doc.defaultView || window;
+
+                    event.initUIEvent(type, bubbles, cancelable, view, detail);
+                    return event;
+                },
+
+                fireEvent: function (target, type, event) {
+                    target.dispatchEvent(event);
+                },
+
+                fixTarget: function (target) {
+                    
+                    if (target == window && !target.dispatchEvent) {
+                        return document;
+                    }
+
+                    return target;
+                }
+            };
+        } else if (document.createEventObject) { 
+            crazyIEButtons = { 0: 1, 1: 4, 2: 2 };
+
+            API = {
+                createHtmlEvent: function (doc, type, bubbles, cancelable) {
+                    var event = doc.createEventObject();
+                    event.bubbles = bubbles;
+                    event.cancelable = cancelable;
+                    return event;
+                },
+
+                createMouseEvent: function (doc, type, bubbles, cancelable, detail,
+                                            clientX, clientY, ctrlKey, altKey, shiftKey, metaKey,
+                                            button, relatedTarget) {
+                    var event = doc.createEventObject();
+                    event.bubbles = bubbles;
+                    event.cancelable = cancelable;
+                    event.detail = detail;
+                    event.screenX = clientX;
+                    event.screenY = clientY;
+                    event.clientX = clientX;
+                    event.clientY = clientY;
+                    event.ctrlKey = ctrlKey;
+                    event.altKey = altKey;
+                    event.shiftKey = shiftKey;
+                    event.metaKey = metaKey;
+                    event.button = crazyIEButtons[button] || button;
+                    event.relatedTarget = relatedTarget; 
+                    return event;
+                },
+
+                createUIEvent: function (doc, type, bubbles, cancelable, detail) {
+                    var event = doc.createEventObject();
+                    event.bubbles = bubbles;
+                    event.cancelable = cancelable;
+                    return event;
+                },
+
+                fireEvent: function (target, type, event) {
+                    target.fireEvent('on' + type, event);
+                },
+
+                fixTarget: function (target) {
+                    if (target == document) {
+                        
+                        
+                        return document.documentElement;
+                    }
+
+                    return target;
+                }
+            };
+        }
+
+        
+        
+
+        Ext.Object.each({
+                load:   [false, false],
+                unload: [false, false],
+                select: [true, false],
+                change: [true, false],
+                submit: [true, true],
+                reset:  [true, false],
+                resize: [true, false],
+                scroll: [true, false]
+            },
+            function (name, value) {
+                var bubbles = value[0], cancelable = value[1];
+                dispatchers[name] = function (targetEl, srcEvent) {
+                    var e = API.createHtmlEvent(name, bubbles, cancelable);
+                    API.fireEvent(targetEl, name, e);
+                };
+            });
+
+        
+        
+
+        function createMouseEventDispatcher (type, detail) {
+            var cancelable = (type != 'mousemove');
+            return function (targetEl, srcEvent) {
+                var xy = srcEvent.getXY(),
+                    e = API.createMouseEvent(targetEl.ownerDocument, type, true, cancelable,
+                                detail, xy[0], xy[1], srcEvent.ctrlKey, srcEvent.altKey,
+                                srcEvent.shiftKey, srcEvent.metaKey, srcEvent.button,
+                                srcEvent.relatedTarget);
+                API.fireEvent(targetEl, type, e);
+            };
+        }
+
+        Ext.each(['click', 'dblclick', 'mousedown', 'mouseup', 'mouseover', 'mousemove', 'mouseout'],
+            function (eventName) {
+                dispatchers[eventName] = createMouseEventDispatcher(eventName, 1);
+            });
+
+        
+        
+
+        Ext.Object.each({
+                focusin:  [true, false],
+                focusout: [true, false],
+                activate: [true, true],
+                focus:    [false, false],
+                blur:     [false, false]
+            },
+            function (name, value) {
+                var bubbles = value[0], cancelable = value[1];
+                dispatchers[name] = function (targetEl, srcEvent) {
+                    var e = API.createUIEvent(targetEl.ownerDocument, name, bubbles, cancelable, 1);
+                    API.fireEvent(targetEl, name, e);
+                };
+            });
+
+        
+        if (!API) {
+            
+
+            dispatchers = {}; 
+
+            API = {
+                fixTarget: function (t) {
+                    return t;
+                }
+            };
+        }
+
+        function cannotInject (target, srcEvent) {
+        }
+
+        return function (target) {
+            var me = this,
+                dispatcher = dispatchers[me.type] || cannotInject,
+                t = target ? (target.dom || target) : me.getTarget();
+
+            t = API.fixTarget(t);
+            dispatcher(t, me);
+        };
+    }()) 
+
+}, function() {
+
+Ext.EventObject = new Ext.EventObjectImpl();
+
+});
+
+
+//@tag dom,core
+
+//@require ../EventObject.js
+
+
+
+Ext.define('Ext.dom.AbstractQuery', {
+    
+    select: function(q, root) {
+        var results = [],
+            nodes,
+            i,
+            j,
+            qlen,
+            nlen;
+
+        root = root || document;
+
+        if (typeof root == 'string') {
+            root = document.getElementById(root);
+        }
+
+        q = q.split(",");
+
+        for (i = 0,qlen = q.length; i < qlen; i++) {
+            if (typeof q[i] == 'string') {
+                
+                
+                if (typeof q[i][0] == '@') {
+                    nodes = root.getAttributeNode(q[i].substring(1));
+                    results.push(nodes);
+                } else {
+                    nodes = root.querySelectorAll(q[i]);
+
+                    for (j = 0,nlen = nodes.length; j < nlen; j++) {
+                        results.push(nodes[j]);
+                    }
+                }
+            }
+        }
+
+        return results;
+    },
+
+    
+    selectNode: function(q, root) {
+        return this.select(q, root)[0];
+    },
+
+    
+    is: function(el, q) {
+        if (typeof el == "string") {
+            el = document.getElementById(el);
+        }
+        return this.select(q).indexOf(el) !== -1;
+    }
+
+});
+
+//@tag dom,core
+
+//@require AbstractQuery.js
+
+
+
+Ext.define('Ext.dom.AbstractHelper', {
+    emptyTags : /^(?:br|frame|hr|img|input|link|meta|range|spacer|wbr|area|param|col)$/i,
+    confRe : /(?:tag|children|cn|html|tpl|tplData)$/i,
+    endRe : /end/i,
+
+    
+    attributeTransform: { cls : 'class', htmlFor : 'for' },
+
+    closeTags: {},
+
+    decamelizeName : (function () {
+        var camelCaseRe = /([a-z])([A-Z])/g,
+            cache = {};
+
+        function decamel (match, p1, p2) {
+            return p1 + '-' + p2.toLowerCase();
+        }
+
+        return function (s) {
+            return cache[s] || (cache[s] = s.replace(camelCaseRe, decamel));
+        };
+    }()),
+
+    generateMarkup: function(spec, buffer) {
+        var me = this,
+            attr, val, tag, i, closeTags;
+
+        if (typeof spec == "string") {
+            buffer.push(spec);
+        } else if (Ext.isArray(spec)) {
+            for (i = 0; i < spec.length; i++) {
+                if (spec[i]) {
+                    me.generateMarkup(spec[i], buffer);
+                }
+            }
+        } else {
+            tag = spec.tag || 'div';
+            buffer.push('<', tag);
+
+            for (attr in spec) {
+                if (spec.hasOwnProperty(attr)) {
+                    val = spec[attr];
+                    if (!me.confRe.test(attr)) {
+                        if (typeof val == "object") {
+                            buffer.push(' ', attr, '="');
+                            me.generateStyles(val, buffer).push('"');
+                        } else {
+                            buffer.push(' ', me.attributeTransform[attr] || attr, '="', val, '"');
+                        }
+                    }
+                }
+            }
+
+            
+            if (me.emptyTags.test(tag)) {
+                buffer.push('/>');
+            } else {
+                buffer.push('>');
+
+                
+                if ((val = spec.tpl)) {
+                    val.applyOut(spec.tplData, buffer);
+                }
+                if ((val = spec.html)) {
+                    buffer.push(val);
+                }
+                if ((val = spec.cn || spec.children)) {
+                    me.generateMarkup(val, buffer);
+                }
+
+                
+                closeTags = me.closeTags;
+                buffer.push(closeTags[tag] || (closeTags[tag] = '</' + tag + '>'));
+            }
+        }
+
+        return buffer;
+    },
+
+    
+    generateStyles: function (styles, buffer) {
+        var a = buffer || [],
+            name;
+
+        for (name in styles) {
+            if (styles.hasOwnProperty(name)) {
+                a.push(this.decamelizeName(name), ':', styles[name], ';');
+            }
+        }
+
+        return buffer || a.join('');
+    },
+
+    
+    markup: function(spec) {
+        if (typeof spec == "string") {
+            return spec;
+        }
+
+        var buf = this.generateMarkup(spec, []);
+        return buf.join('');
+    },
+
+    
+    applyStyles: function(el, styles) {
+        if (styles) {
+            var i = 0,
+                len,
+                style;
+
+            el = Ext.fly(el);
+            if (typeof styles == 'function') {
+                styles = styles.call();
+            }
+            if (typeof styles == 'string'){
+                styles = Ext.util.Format.trim(styles).split(/\s*(?::|;)\s*/);
+                for(len = styles.length; i < len;){
+                    el.setStyle(styles[i++], styles[i++]);
+                }
+            } else if (Ext.isObject(styles)) {
+                el.setStyle(styles);
+            }
+        }
+    },
+
+    
+    insertHtml: function(where, el, html) {
+        var hash = {},
+            hashVal,
+            setStart,
+            range,
+            frag,
+            rangeEl,
+            rs;
+
+        where = where.toLowerCase();
+
+        
+        hash['beforebegin'] = ['BeforeBegin', 'previousSibling'];
+        hash['afterend'] = ['AfterEnd', 'nextSibling'];
+
+        range = el.ownerDocument.createRange();
+        setStart = 'setStart' + (this.endRe.test(where) ? 'After' : 'Before');
+        if (hash[where]) {
+            range[setStart](el);
+            frag = range.createContextualFragment(html);
+            el.parentNode.insertBefore(frag, where == 'beforebegin' ? el : el.nextSibling);
+            return el[(where == 'beforebegin' ? 'previous' : 'next') + 'Sibling'];
+        }
+        else {
+            rangeEl = (where == 'afterbegin' ? 'first' : 'last') + 'Child';
+            if (el.firstChild) {
+                range[setStart](el[rangeEl]);
+                frag = range.createContextualFragment(html);
+                if (where == 'afterbegin') {
+                    el.insertBefore(frag, el.firstChild);
+                }
+                else {
+                    el.appendChild(frag);
+                }
+            }
+            else {
+                el.innerHTML = html;
+            }
+            return el[rangeEl];
+        }
+
+        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');
+    },
+
+    
+    append: function(el, o, returnElement) {
+        return this.doInsert(el, o, returnElement, 'beforeend', '', true);
+    },
+
+    
+    overwrite: function(el, o, returnElement) {
+        el = Ext.getDom(el);
+        el.innerHTML = this.markup(o);
+        return returnElement ? Ext.get(el.firstChild) : el.firstChild;
+    },
+
+    doInsert: function(el, o, returnElement, pos, sibling, append) {
+        var newNode = this.insertHtml(pos, Ext.getDom(el), this.markup(o));
+        return returnElement ? Ext.get(newNode, true) : newNode;
+    }
+
+});
+
+//@tag dom,core
+
+//@require AbstractHelper.js
+
+//@require Ext.Supports
+
+//@require Ext.EventManager
+
+//@define Ext.dom.AbstractElement
+
+
+
+(function() {
+
+var document = window.document,
+    trimRe = /^\s+|\s+$/g,
+    whitespaceRe = /\s/;
+
+if (!Ext.cache){
+    Ext.cache = {};
+}
+
+Ext.define('Ext.dom.AbstractElement', {
+
+    inheritableStatics: {
+
+        
+        get: function(el) {
+            var me = this,
+                El = Ext.dom.Element,
+                cacheItem,
+                extEl,
+                dom,
+                id;
+
+            if (!el) {
+                return null;
+            }
+
+            if (typeof el == "string") { 
+                if (el == Ext.windowId) {
+                    return El.get(window);
+                } else if (el == Ext.documentId) {
+                    return El.get(document);
+                }
+                
+                cacheItem = Ext.cache[el];
+                
+                
+                
+                
+                if (cacheItem && cacheItem.skipGarbageCollection) {
+                    extEl = cacheItem.el;
+                    return extEl;
+                }
+                
+                if (!(dom = document.getElementById(el))) {
+                    return null;
+                }
+
+                if (cacheItem && cacheItem.el) {
+                    extEl = Ext.updateCacheEntry(cacheItem, dom).el;
+                } else {
+                    
+                    extEl = new El(dom, !!cacheItem);
+                }
+                return extEl;
+            } else if (el.tagName) { 
+                if (!(id = el.id)) {
+                    id = Ext.id(el);
+                }
+                cacheItem = Ext.cache[id];
+                if (cacheItem && cacheItem.el) {
+                    extEl = Ext.updateCacheEntry(cacheItem, el).el;
+                } else {
+                    
+                    extEl = new El(el, !!cacheItem);
+                }
+                return extEl;
+            } else if (el instanceof me) {
+                if (el != me.docEl && el != me.winEl) {
+                    id = el.id;
+                    
+                    
+                    cacheItem = Ext.cache[id];
+                    if (cacheItem) {
+                        Ext.updateCacheEntry(cacheItem, document.getElementById(id) || el.dom);
+                    }
+                }
+                return el;
+            } else if (el.isComposite) {
+                return el;
+            } else if (Ext.isArray(el)) {
+                return me.select(el);
+            } else if (el === document) {
+                
+                if (!me.docEl) {
+                    me.docEl = Ext.Object.chain(El.prototype);
+                    me.docEl.dom = document;
+                    me.docEl.id = Ext.id(document);
+                    me.addToCache(me.docEl);
+                }
+                return me.docEl;
+            } else if (el === window) {
+                if (!me.winEl) {
+                    me.winEl = Ext.Object.chain(El.prototype);
+                    me.winEl.dom = window;
+                    me.winEl.id = Ext.id(window);
+                    me.addToCache(me.winEl);
+                }
+                return me.winEl;
+            }
+            return null;
+        },
+
+        addToCache: function(el, id) {
+            if (el) {
+                Ext.addCacheEntry(id, el);
+            }
+            return el;
+        },
+
+        addMethods: function() {
+            this.override.apply(this, arguments);
+        },
+
+        
+        mergeClsList: function() {
+            var clsList, clsHash = {},
+                i, length, j, listLength, clsName, result = [],
+                changed = false;
+
+            for (i = 0, length = arguments.length; i < length; i++) {
+                clsList = arguments[i];
+                if (Ext.isString(clsList)) {
+                    clsList = clsList.replace(trimRe, '').split(whitespaceRe);
+                }
+                if (clsList) {
+                    for (j = 0, listLength = clsList.length; j < listLength; j++) {
+                        clsName = clsList[j];
+                        if (!clsHash[clsName]) {
+                            if (i) {
+                                changed = true;
+                            }
+                            clsHash[clsName] = true;
+                        }
+                    }
+                }
+            }
+
+            for (clsName in clsHash) {
+                result.push(clsName);
+            }
+            result.changed = changed;
+            return result;
+        },
+
+        
+        removeCls: function(existingClsList, removeClsList) {
+            var clsHash = {},
+                i, length, clsName, result = [],
+                changed = false;
+
+            if (existingClsList) {
+                if (Ext.isString(existingClsList)) {
+                    existingClsList = existingClsList.replace(trimRe, '').split(whitespaceRe);
+                }
+                for (i = 0, length = existingClsList.length; i < length; i++) {
+                    clsHash[existingClsList[i]] = true;
+                }
+            }
+            if (removeClsList) {
+                if (Ext.isString(removeClsList)) {
+                    removeClsList = removeClsList.split(whitespaceRe);
+                }
+                for (i = 0, length = removeClsList.length; i < length; i++) {
+                    clsName = removeClsList[i];
+                    if (clsHash[clsName]) {
+                        changed = true;
+                        delete clsHash[clsName];
+                    }
+                }
+            }
+            for (clsName in clsHash) {
+                result.push(clsName);
+            }
+            result.changed = changed;
+            return result;
+        },
+
+        
+        VISIBILITY: 1,
+
+        
+        DISPLAY: 2,
+
+        
+        OFFSETS: 3,
+
+        
+        ASCLASS: 4
+    },
+
+    constructor: function(element, forceNew) {
+        var me = this,
+            dom = typeof element == 'string'
+                ? document.getElementById(element)
+                : element,
+            id;
+
+        if (!dom) {
+            return null;
+        }
+
+        id = dom.id;
+        if (!forceNew && id && Ext.cache[id]) {
+            
+            return Ext.cache[id].el;
+        }
+
+        
+        me.dom = dom;
+
+        
+        me.id = id || Ext.id(dom);
+
+        me.self.addToCache(me);
+    },
+
+    
+    set: function(o, useSet) {
+         var el = this.dom,
+             attr,
+             value;
+
+         for (attr in o) {
+             if (o.hasOwnProperty(attr)) {
+                 value = o[attr];
+                 if (attr == 'style') {
+                     this.applyStyles(value);
+                 }
+                 else if (attr == 'cls') {
+                     el.className = value;
+                 }
+                 else if (useSet !== false) {
+                     if (value === undefined) {
+                         el.removeAttribute(attr);
+                     } else {
+                        el.setAttribute(attr, value);
+                     }
+                 }
+                 else {
+                     el[attr] = value;
+                 }
+             }
+         }
+         return this;
+     },
+
+    
+    defaultUnit: "px",
+
+    
+    is: function(simpleSelector) {
+        return Ext.DomQuery.is(this.dom, simpleSelector);
+    },
+
+    
+    getValue: function(asNumber) {
+        var val = this.dom.value;
+        return asNumber ? parseInt(val, 10) : val;
+    },
+
+    
+    remove: function() {
+        var me = this,
+        dom = me.dom;
+
+        if (dom) {
+            Ext.removeNode(dom);
+            delete me.dom;
+        }
+    },
+
+    
+    contains: function(el) {
+        if (!el) {
+            return false;
+        }
+
+        var me = this,
+            dom = el.dom || el;
+
+        
+        return (dom === me.dom) || Ext.dom.AbstractElement.isAncestor(me.dom, dom);
+    },
+
+    
+    getAttribute: function(name, ns) {
+        var dom = this.dom;
+        return dom.getAttributeNS(ns, name) || dom.getAttribute(ns + ":" + name) || dom.getAttribute(name) || dom[name];
+    },
+
+    
+    update: function(html) {
+        if (this.dom) {
+            this.dom.innerHTML = html;
+        }
+        return this;
+    },
+
+
+    
+    setHTML: function(html) {
+        if(this.dom) {
+            this.dom.innerHTML = html;
+        }
+        return this;
+    },
+
+    
+    getHTML: function() {
+        return this.dom ? this.dom.innerHTML : '';
+    },
+
+    
+    hide: function() {
+        this.setVisible(false);
+        return this;
+    },
+
+    
+    show: function() {
+        this.setVisible(true);
+        return this;
+    },
+
+    
+    setVisible: function(visible, animate) {
+        var me = this,
+            statics = me.self,
+            mode = me.getVisibilityMode(),
+            prefix = Ext.baseCSSPrefix;
+
+        switch (mode) {
+            case statics.VISIBILITY:
+                me.removeCls([prefix + 'hidden-display', prefix + 'hidden-offsets']);
+                me[visible ? 'removeCls' : 'addCls'](prefix + 'hidden-visibility');
+            break;
+
+            case statics.DISPLAY:
+                me.removeCls([prefix + 'hidden-visibility', prefix + 'hidden-offsets']);
+                me[visible ? 'removeCls' : 'addCls'](prefix + 'hidden-display');
+            break;
+
+            case statics.OFFSETS:
+                me.removeCls([prefix + 'hidden-visibility', prefix + 'hidden-display']);
+                me[visible ? 'removeCls' : 'addCls'](prefix + 'hidden-offsets');
+            break;
+        }
+
+        return me;
+    },
+
+    getVisibilityMode: function() {
+        
+        
+        
+        var data = (this.$cache || this.getCache()).data,
+            visMode = data.visibilityMode;
+
+        if (visMode === undefined) {
+            data.visibilityMode = visMode = this.self.DISPLAY;
+        }
+        
+        return visMode;
+    },
+
+    
+    setVisibilityMode: function(mode) {
+        (this.$cache || this.getCache()).data.visibilityMode = mode;
+        return this;
+    },
+    
+    getCache: function() {
+        var me = this,
+            id = me.dom.id || Ext.id(me.dom);
+
+        
+        
+        
+        me.$cache = Ext.cache[id] || Ext.addCacheEntry(id, null, me.dom);
+            
+        return me.$cache;
+    }
+    
+}, function() {
+    var AbstractElement = this;
+
+    
+    Ext.getDetachedBody = function () {
+        var detachedEl = AbstractElement.detachedBodyEl;
+
+        if (!detachedEl) {
+            detachedEl = document.createElement('div');
+            AbstractElement.detachedBodyEl = detachedEl = new AbstractElement.Fly(detachedEl);
+            detachedEl.isDetachedBody = true;
+        }
+
+        return detachedEl;
+    };
+
+    
+    Ext.getElementById = function (id) {
+        var el = document.getElementById(id),
+            detachedBodyEl;
+
+        if (!el && (detachedBodyEl = AbstractElement.detachedBodyEl)) {
+            el = detachedBodyEl.dom.querySelector('#' + Ext.escapeId(id));
+        }
+
+        return el;
+    };
+
+    
+    Ext.get = function(el) {
+        return Ext.dom.Element.get(el);
+    };
+
+    this.addStatics({
+        
+        Fly: new Ext.Class({
+            extend: AbstractElement,
+
+            
+            isFly: true,
+
+            constructor: function(dom) {
+                this.dom = dom;
+            },
+
+            
+            attach: function (dom) {
+
+                
+                this.dom = dom;
+                
+                
+                this.$cache = dom.id ? Ext.cache[dom.id] : null;
+                return this;
+            }
+        }),
+
+        _flyweights: {},
+
+        
+        fly: function(dom, named) {
+            var fly = null,
+                _flyweights = AbstractElement._flyweights;
+
+            named = named || '_global';
+
+            dom = Ext.getDom(dom);
+
+            if (dom) {
+                fly = _flyweights[named] || (_flyweights[named] = new AbstractElement.Fly());
+
+                
+                
+                fly.dom = dom;
+                
+                
+                fly.$cache = dom.id ? Ext.cache[dom.id] : null;
+            }
+            return fly;
+        }
+    });
+
+    
+    Ext.fly = function() {
+        return AbstractElement.fly.apply(AbstractElement, arguments);
+    };
+
+    (function (proto) {
+        
+        proto.destroy = proto.remove;
+
+        
+        if (document.querySelector) {
+            proto.getById = function (id, asDom) {
+                
+                
+                var dom = document.getElementById(id) ||
+                    this.dom.querySelector('#'+Ext.escapeId(id));
+                return asDom ? dom : (dom ? Ext.get(dom) : null);
+            };
+        } else {
+            proto.getById = function (id, asDom) {
+                var dom = document.getElementById(id);
+                return asDom ? dom : (dom ? Ext.get(dom) : null);
+            };
+        }
+    }(this.prototype));
+});
+
+}());
+
+//@tag dom,core
+
+//@require AbstractElement.js
+
+//@define Ext.dom.AbstractElement-static
+
+//@define Ext.dom.AbstractElement
+
+
+
+Ext.dom.AbstractElement.addInheritableStatics({
+    unitRe: /\d+(px|em|%|en|ex|pt|in|cm|mm|pc)$/i,
+    camelRe: /(-[a-z])/gi,
+    cssRe: /([a-z0-9\-]+)\s*:\s*([^;\s]+(?:\s*[^;\s]+)*);?/gi,
+    opacityRe: /alpha\(opacity=(.*)\)/i,
+    propertyCache: {},
+    defaultUnit : "px",
+    borders: {l: 'border-left-width', r: 'border-right-width', t: 'border-top-width', b: 'border-bottom-width'},
+    paddings: {l: 'padding-left', r: 'padding-right', t: 'padding-top', b: 'padding-bottom'},
+    margins: {l: 'margin-left', r: 'margin-right', t: 'margin-top', b: 'margin-bottom'},
+    
+    addUnits: function(size, units) {
+        
+        if (typeof size == 'number') {
+            return size + (units || this.defaultUnit || 'px');
+        }
+
+        
+        if (size === "" || size == "auto" || size === undefined || size === null) {
+            return size || '';
+        }
+
+        
+        if (!this.unitRe.test(size)) {
+            return size || '';
+        }
+
+        return size;
+    },
+
+    
+    isAncestor: function(p, c) {
+        var ret = false;
+
+        p = Ext.getDom(p);
+        c = Ext.getDom(c);
+        if (p && c) {
+            if (p.contains) {
+                return p.contains(c);
+            } else if (p.compareDocumentPosition) {
+                return !!(p.compareDocumentPosition(c) & 16);
+            } else {
+                while ((c = c.parentNode)) {
+                    ret = c == p || ret;
+                }
+            }
+        }
+        return ret;
+    },
+
+    
+    parseBox: function(box) {
+        if (typeof box != 'string') {
+            box = box.toString();
+        }
+        var parts  = box.split(' '),
+            ln = parts.length;
+
+        if (ln == 1) {
+            parts[1] = parts[2] = parts[3] = parts[0];
+        }
+        else if (ln == 2) {
+            parts[2] = parts[0];
+            parts[3] = parts[1];
+        }
+        else if (ln == 3) {
+            parts[3] = parts[1];
+        }
+
+        return {
+            top   :parseFloat(parts[0]) || 0,
+            right :parseFloat(parts[1]) || 0,
+            bottom:parseFloat(parts[2]) || 0,
+            left  :parseFloat(parts[3]) || 0
+        };
+    },
+
+    
+    unitizeBox: function(box, units) {
+        var a = this.addUnits,
+            b = this.parseBox(box);
+
+        return a(b.top, units) + ' ' +
+               a(b.right, units) + ' ' +
+               a(b.bottom, units) + ' ' +
+               a(b.left, units);
+
+    },
+
+    
+    camelReplaceFn: function(m, a) {
+        return a.charAt(1).toUpperCase();
+    },
+
+    
+    normalize: function(prop) {
+        
+        if (prop == 'float') {
+            prop = Ext.supports.Float ? 'cssFloat' : 'styleFloat';
+        }
+        return this.propertyCache[prop] || (this.propertyCache[prop] = prop.replace(this.camelRe, this.camelReplaceFn));
+    },
+
+    
+    getDocumentHeight: function() {
+        return Math.max(!Ext.isStrict ? document.body.scrollHeight : document.documentElement.scrollHeight, this.getViewportHeight());
+    },
+
+    
+    getDocumentWidth: function() {
+        return Math.max(!Ext.isStrict ? document.body.scrollWidth : document.documentElement.scrollWidth, this.getViewportWidth());
+    },
+
+    
+    getViewportHeight: function(){
+        return window.innerHeight;
+    },
+
+    
+    getViewportWidth: function() {
+        return window.innerWidth;
+    },
+
+    
+    getViewSize: function() {
+        return {
+            width: window.innerWidth,
+            height: window.innerHeight
+        };
+    },
+
+    
+    getOrientation: function() {
+        if (Ext.supports.OrientationChange) {
+            return (window.orientation == 0) ? 'portrait' : 'landscape';
+        }
+
+        return (window.innerHeight > window.innerWidth) ? 'portrait' : 'landscape';
+    },
+
+    
+    fromPoint: function(x, y) {
+        return Ext.get(document.elementFromPoint(x, y));
+    },
+
+    
+    parseStyles: function(styles){
+        var out = {},
+            cssRe = this.cssRe,
+            matches;
+
+        if (styles) {
+            
+            
+            
+            
+            cssRe.lastIndex = 0;
+            while ((matches = cssRe.exec(styles))) {
+                out[matches[1]] = matches[2];
+            }
+        }
+        return out;
+    }
+});
+
+
+(function(){
+    var doc = document,
+        AbstractElement = Ext.dom.AbstractElement,
+        activeElement = null,
+        isCSS1 = doc.compatMode == "CSS1Compat",
+        flyInstance,
+        fly = function (el) {
+            if (!flyInstance) {
+                flyInstance = new AbstractElement.Fly();
+            }
+            flyInstance.attach(el);
+            return flyInstance;
+        };
+
+    
+    
+    
+    if (!('activeElement' in doc) && doc.addEventListener) {
+        doc.addEventListener('focus',
+            function (ev) {
+                if (ev && ev.target) {
+                    activeElement = (ev.target == doc) ? null : ev.target;
+                }
+            }, true);
+    }
+
+    
+    function makeSelectionRestoreFn (activeEl, start, end) {
+        return function () {
+            activeEl.selectionStart = start;
+            activeEl.selectionEnd = end;
+        };
+    }
+
+    AbstractElement.addInheritableStatics({
+        
+        getActiveElement: function () {
+            return doc.activeElement || activeElement;
+        },
+
+        
+        getRightMarginFixCleaner: function (target) {
+            var supports = Ext.supports,
+                hasInputBug = supports.DisplayChangeInputSelectionBug,
+                hasTextAreaBug = supports.DisplayChangeTextAreaSelectionBug,
+                activeEl,
+                tag,
+                start,
+                end;
+
+            if (hasInputBug || hasTextAreaBug) {
+                activeEl = doc.activeElement || activeElement; 
+                tag = activeEl && activeEl.tagName;
+
+                if ((hasTextAreaBug && tag == 'TEXTAREA') ||
+                    (hasInputBug && tag == 'INPUT' && activeEl.type == 'text')) {
+                    if (Ext.dom.Element.isAncestor(target, activeEl)) {
+                        start = activeEl.selectionStart;
+                        end = activeEl.selectionEnd;
+
+                        if (Ext.isNumber(start) && Ext.isNumber(end)) { 
+                            
+                            
+                            
+                            
+                            return makeSelectionRestoreFn(activeEl, start, end);
+                        }
+                    }
+                }
+            }
+
+            return Ext.emptyFn; 
+        },
+
+        getViewWidth: function(full) {
+            return full ? Ext.dom.Element.getDocumentWidth() : Ext.dom.Element.getViewportWidth();
+        },
+
+        getViewHeight: function(full) {
+            return full ? Ext.dom.Element.getDocumentHeight() : Ext.dom.Element.getViewportHeight();
+        },
+
+        getDocumentHeight: function() {
+            return Math.max(!isCSS1 ? doc.body.scrollHeight : doc.documentElement.scrollHeight, Ext.dom.Element.getViewportHeight());
+        },
+
+        getDocumentWidth: function() {
+            return Math.max(!isCSS1 ? doc.body.scrollWidth : doc.documentElement.scrollWidth, Ext.dom.Element.getViewportWidth());
+        },
+
+        getViewportHeight: function(){
+            return Ext.isIE ?
+                   (Ext.isStrict ? doc.documentElement.clientHeight : doc.body.clientHeight) :
+                   self.innerHeight;
+        },
+
+        getViewportWidth: function() {
+            return (!Ext.isStrict && !Ext.isOpera) ? doc.body.clientWidth :
+                   Ext.isIE ? doc.documentElement.clientWidth : self.innerWidth;
+        },
+
+        getY: function(el) {
+            return Ext.dom.Element.getXY(el)[1];
+        },
+
+        getX: function(el) {
+            return Ext.dom.Element.getXY(el)[0];
+        },
+
+        getXY: function(el) {
+            var bd = doc.body,
+                docEl = doc.documentElement,
+                leftBorder = 0,
+                topBorder = 0,
+                ret = [0,0],
+                round = Math.round,
+                box,
+                scroll;
+
+            el = Ext.getDom(el);
+
+            if(el != doc && el != bd){
+                
+                
+                if (Ext.isIE) {
+                    try {
+                        box = el.getBoundingClientRect();
+                        
+                        topBorder = docEl.clientTop || bd.clientTop;
+                        leftBorder = docEl.clientLeft || bd.clientLeft;
+                    } catch (ex) {
+                        box = { left: 0, top: 0 };
+                    }
+                } else {
+                    box = el.getBoundingClientRect();
+                }
+
+                scroll = fly(document).getScroll();
+                ret = [round(box.left + scroll.left - leftBorder), round(box.top + scroll.top - topBorder)];
+            }
+            return ret;
+        },
+
+        setXY: function(el, xy) {
+            (el = Ext.fly(el, '_setXY')).position();
+
+            var pts = el.translatePoints(xy),
+                style = el.dom.style,
+                pos;
+
+            for (pos in pts) {
+                if (!isNaN(pts[pos])) {
+                    style[pos] = pts[pos] + "px";
+                }
+            }
+        },
+
+        setX: function(el, x) {
+            Ext.dom.Element.setXY(el, [x, false]);
+        },
+
+        setY: function(el, y) {
+            Ext.dom.Element.setXY(el, [false, y]);
+        },
+
+        
+        serializeForm: function(form) {
+            var fElements = form.elements || (document.forms[form] || Ext.getDom(form)).elements,
+                hasSubmit = false,
+                encoder   = encodeURIComponent,
+                data      = '',
+                eLen      = fElements.length,
+                element, name, type, options, hasValue, e,
+                o, oLen, opt;
+
+            for (e = 0; e < eLen; e++) {
+                element = fElements[e];
+                name    = element.name;
+                type    = element.type;
+                options = element.options;
+
+                if (!element.disabled && name) {
+                    if (/select-(one|multiple)/i.test(type)) {
+                        oLen = options.length;
+                        for (o = 0; o < oLen; o++) {
+                            opt = options[o];
+                            if (opt.selected) {
+                                hasValue = opt.hasAttribute ? opt.hasAttribute('value') : opt.getAttributeNode('value').specified;
+                                data += Ext.String.format("{0}={1}&", encoder(name), encoder(hasValue ? opt.value : opt.text));
+                            }
+                        }
+                    } else if (!(/file|undefined|reset|button/i.test(type))) {
+                        if (!(/radio|checkbox/i.test(type) && !element.checked) && !(type == 'submit' && hasSubmit)) {
+                            data += encoder(name) + '=' + encoder(element.value) + '&';
+                            hasSubmit = /submit/i.test(type);
+                        }
+                    }
+                }
+            }
+            return data.substr(0, data.length - 1);
+        }
+    });
+}());
+
+//@tag dom,core
+
+//@require Ext.dom.AbstractElement-static
+
+//@define Ext.dom.AbstractElement-alignment
+
+
+
+Ext.dom.AbstractElement.override({
+
+    
+    getAnchorXY: function(anchor, local, size) {
+        
+        
+        anchor = (anchor || "tl").toLowerCase();
+        size = size || {};
+
+        var me = this,
+            vp = me.dom == document.body || me.dom == document,
+            width = size.width || vp ? window.innerWidth: me.getWidth(),
+            height = size.height || vp ? window.innerHeight: me.getHeight(),
+            xy,
+            rnd = Math.round,
+            myXY = me.getXY(),
+            extraX = vp ? 0: !local ? myXY[0] : 0,
+            extraY = vp ? 0: !local ? myXY[1] : 0,
+            hash = {
+                c: [rnd(width * 0.5), rnd(height * 0.5)],
+                t: [rnd(width * 0.5), 0],
+                l: [0, rnd(height * 0.5)],
+                r: [width, rnd(height * 0.5)],
+                b: [rnd(width * 0.5), height],
+                tl: [0, 0],
+                bl: [0, height],
+                br: [width, height],
+                tr: [width, 0]
+            };
+
+        xy = hash[anchor];
+        return [xy[0] + extraX, xy[1] + extraY];
+    },
+
+    alignToRe: /^([a-z]+)-([a-z]+)(\?)?$/,
+
+    
+    getAlignToXY: function(el, position, offsets, local) {
+        local = !!local;
+        el = Ext.get(el);
+
+        offsets = offsets || [0, 0];
+
+        if (!position || position == '?') {
+            position = 'tl-bl?';
+        }
+        else if (! (/-/).test(position) && position !== "") {
+            position = 'tl-' + position;
+        }
+        position = position.toLowerCase();
+
+        var me = this,
+            matches = position.match(this.alignToRe),
+            dw = window.innerWidth,
+            dh = window.innerHeight,
+            p1 = "",
+            p2 = "",
+            a1,
+            a2,
+            x,
+            y,
+            swapX,
+            swapY,
+            p1x,
+            p1y,
+            p2x,
+            p2y,
+            width,
+            height,
+            region,
+            constrain;
+
+        if (!matches) {
+            throw "Element.alignTo with an invalid alignment " + position;
+        }
+
+        p1 = matches[1];
+        p2 = matches[2];
+        constrain = !!matches[3];
+
+        
+        
+        a1 = me.getAnchorXY(p1, true);
+        a2 = el.getAnchorXY(p2, local);
+
+        x = a2[0] - a1[0] + offsets[0];
+        y = a2[1] - a1[1] + offsets[1];
+
+        if (constrain) {
+            width = me.getWidth();
+            height = me.getHeight();
+
+            region = el.getPageBox();
+
+            
+            
+            
+            p1y = p1.charAt(0);
+            p1x = p1.charAt(p1.length - 1);
+            p2y = p2.charAt(0);
+            p2x = p2.charAt(p2.length - 1);
+
+            swapY = ((p1y == "t" && p2y == "b") || (p1y == "b" && p2y == "t"));
+            swapX = ((p1x == "r" && p2x == "l") || (p1x == "l" && p2x == "r"));
+
+            if (x + width > dw) {
+                x = swapX ? region.left - width: dw - width;
+            }
+            if (x < 0) {
+                x = swapX ? region.right: 0;
+            }
+            if (y + height > dh) {
+                y = swapY ? region.top - height: dh - height;
+            }
+            if (y < 0) {
+                y = swapY ? region.bottom: 0;
+            }
+        }
+
+        return [x, y];
+    },
+
+    
+    getAnchor: function(){
+        var data = (this.$cache || this.getCache()).data,
+            anchor;
+            
+        if (!this.dom) {
+            return;
+        }
+        anchor = data._anchor;
+
+        if(!anchor){
+            anchor = data._anchor = {};
+        }
+        return anchor;
+    },
+
+    
+    adjustForConstraints: function(xy, parent) {
+        var vector = this.getConstrainVector(parent, xy);
+        if (vector) {
+            xy[0] += vector[0];
+            xy[1] += vector[1];
+        }
+        return xy;
+    }
+
+});
+
+//@tag dom,core
+
+//@require Ext.dom.AbstractElement-alignment
+
+//@define Ext.dom.AbstractElement-insertion
+
+//@define Ext.dom.AbstractElement
+
+
+
+Ext.dom.AbstractElement.addMethods({
+    
+    appendChild: function(el) {
+        return Ext.get(el).appendTo(this);
+    },
+
+    
+    appendTo: function(el) {
+        Ext.getDom(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 (el.nodeType || el.dom || typeof el == 'string') { 
+            el = Ext.getDom(el);
+            this.dom.insertBefore(el, this.dom.firstChild);
+            return !returnDom ? Ext.get(el) : el;
+        }
+        else { 
+            return this.createChild(el, this.dom.firstChild, returnDom);
+        }
+    },
+
+    
+    insertSibling: function(el, where, returnDom){
+        var me      = this,
+            isAfter = (where || 'before').toLowerCase() == 'after',
+            rt, insertEl, eLen, e;
+
+        if (Ext.isArray(el)) {
+            insertEl = me;
+            eLen = el.length;
+            
+            for (e = 0; e < eLen; e++) {
+                rt = Ext.fly(insertEl, '_internal').insertSibling(el[e], where, returnDom);
+
+                if (isAfter) {
+                    insertEl = rt;
+                }
+            }
+
+            return rt;
+        }
+
+        el = el || {};
+
+        if(el.nodeType || el.dom){
+            rt = me.dom.parentNode.insertBefore(Ext.getDom(el), isAfter ? me.dom.nextSibling : me.dom);
+            if (!returnDom) {
+                rt = Ext.get(rt);
+            }
+        }else{
+            if (isAfter && !me.dom.nextSibling) {
+                rt = Ext.core.DomHelper.append(me.dom.parentNode, el, !returnDom);
+            } else {
+                rt = Ext.core.DomHelper[isAfter ? 'insertAfter' : 'insertBefore'](me.dom, el, !returnDom);
+            }
+        }
+        return rt;
+    },
+
+    
+    replace: function(el) {
+        el = Ext.get(el);
+        this.insertBefore(el);
+        el.remove();
+        return this;
+    },
+
+    
+    replaceWith: function(el){
+        var me = this;
+
+        if(el.nodeType || el.dom || typeof el == 'string'){
+            el = Ext.get(el);
+            me.dom.parentNode.insertBefore(el, me.dom);
+        }else{
+            el = Ext.core.DomHelper.insertBefore(me.dom, el);
+        }
+
+        delete Ext.cache[me.id];
+        Ext.removeNode(me.dom);
+        me.id = Ext.id(me.dom = el);
+        Ext.dom.AbstractElement.addToCache(me.isFlyweight ? new Ext.dom.AbstractElement(me.dom) : me);
+        return me;
+    },
+
+    
+    createChild: function(config, insertBefore, returnDom) {
+        config = config || {tag:'div'};
+        if (insertBefore) {
+            return Ext.core.DomHelper.insertBefore(insertBefore, config, returnDom !== true);
+        }
+        else {
+            return Ext.core.DomHelper[!this.dom.firstChild ? 'insertFirst' : 'append'](this.dom, config,  returnDom !== true);
+        }
+    },
+
+    
+    wrap: function(config, returnDom, selector) {
+        var newEl = Ext.core.DomHelper.insertBefore(this.dom, config || {tag: "div"}, true),
+            target = newEl;
+        
+        if (selector) {
+            target = Ext.DomQuery.selectNode(selector, newEl.dom);
+        }
+
+        target.appendChild(this.dom);
+        return returnDom ? newEl.dom : newEl;
+    },
+
+    
+    insertHtml: function(where, html, returnEl) {
+        var el = Ext.core.DomHelper.insertHtml(where, this.dom, html);
+        return returnEl ? Ext.get(el) : el;
+    }
+});
+
+//@tag dom,core
+
+//@require Ext.dom.AbstractElement-insertion
+
+//@define Ext.dom.AbstractElement-position
+
+//@define Ext.dom.AbstractElement
+
+
+
+(function(){
+
+var Element = Ext.dom.AbstractElement;
+
+Element.override({
+
+    
+    getX: function(el) {
+        return this.getXY(el)[0];
+    },
+
+    
+    getY: function(el) {
+        return this.getXY(el)[1];
+    },
+
+    
+    getXY: function() {
+        
+        var point = window.webkitConvertPointFromNodeToPage(this.dom, new WebKitPoint(0, 0));
+        return [point.x, point.y];
+    },
+
+    
+    getOffsetsTo: function(el){
+        var o = this.getXY(),
+            e = Ext.fly(el, '_internal').getXY();
+        return [o[0]-e[0],o[1]-e[1]];
+    },
+
+    
+    setX: function(x){
+        return this.setXY([x, this.getY()]);
+    },
+
+    
+    setY: function(y) {
+        return this.setXY([this.getX(), y]);
+    },
+
+    
+    setLeft: function(left) {
+        this.setStyle('left', Element.addUnits(left));
+        return this;
+    },
+
+    
+    setTop: function(top) {
+        this.setStyle('top', Element.addUnits(top));
+        return this;
+    },
+
+    
+    setRight: function(right) {
+        this.setStyle('right', Element.addUnits(right));
+        return this;
+    },
+
+    
+    setBottom: function(bottom) {
+        this.setStyle('bottom', Element.addUnits(bottom));
+        return this;
+    },
+
+    
+    setXY: function(pos) {
+        var me = this,
+            pts,
+            style,
+            pt;
+
+        if (arguments.length > 1) {
+            pos = [pos, arguments[1]];
+        }
+
+        
+        pts = me.translatePoints(pos);
+        style = me.dom.style;
+
+        for (pt in pts) {
+            if (!pts.hasOwnProperty(pt)) {
+                continue;
+            }
+            if (!isNaN(pts[pt])) {
+                style[pt] = pts[pt] + "px";
+            }
+        }
+        return me;
+    },
+
+    
+    getLeft: function(local) {
+        return parseInt(this.getStyle('left'), 10) || 0;
+    },
+
+    
+    getRight: function(local) {
+        return parseInt(this.getStyle('right'), 10) || 0;
+    },
+
+    
+    getTop: function(local) {
+        return parseInt(this.getStyle('top'), 10) || 0;
+    },
+
+    
+    getBottom: function(local) {
+        return parseInt(this.getStyle('bottom'), 10) || 0;
+    },
+
+    
+    translatePoints: function(x, y) {
+        y = isNaN(x[1]) ? y : x[1];
+        x = isNaN(x[0]) ? x : x[0];
+        var me = this,
+            relative = me.isStyle('position', 'relative'),
+            o = me.getXY(),
+            l = parseInt(me.getStyle('left'), 10),
+            t = parseInt(me.getStyle('top'), 10);
+
+        l = !isNaN(l) ? l : (relative ? 0 : me.dom.offsetLeft);
+        t = !isNaN(t) ? t : (relative ? 0 : me.dom.offsetTop);
+
+        return {left: (x - o[0] + l), top: (y - o[1] + t)};
+    },
+
+    
+    setBox: function(box) {
+        var me = this,
+            width = box.width,
+            height = box.height,
+            top = box.top,
+            left = box.left;
+
+        if (left !== undefined) {
+            me.setLeft(left);
+        }
+        if (top !== undefined) {
+            me.setTop(top);
+        }
+        if (width !== undefined) {
+            me.setWidth(width);
+        }
+        if (height !== undefined) {
+            me.setHeight(height);
+        }
+
+        return this;
+    },
+
+    
+    getBox: function(contentBox, local) {
+        var me = this,
+            dom = me.dom,
+            width = dom.offsetWidth,
+            height = dom.offsetHeight,
+            xy, box, l, r, t, b;
+
+        if (!local) {
+            xy = me.getXY();
+        }
+        else if (contentBox) {
+            xy = [0,0];
+        }
+        else {
+            xy = [parseInt(me.getStyle("left"), 10) || 0, parseInt(me.getStyle("top"), 10) || 0];
+        }
+
+        if (!contentBox) {
+            box = {
+                x: xy[0],
+                y: xy[1],
+                0: xy[0],
+                1: xy[1],
+                width: width,
+                height: height
+            };
+        }
+        else {
+            l = me.getBorderWidth.call(me, "l") + me.getPadding.call(me, "l");
+            r = me.getBorderWidth.call(me, "r") + me.getPadding.call(me, "r");
+            t = me.getBorderWidth.call(me, "t") + me.getPadding.call(me, "t");
+            b = me.getBorderWidth.call(me, "b") + me.getPadding.call(me, "b");
+            box = {
+                x: xy[0] + l,
+                y: xy[1] + t,
+                0: xy[0] + l,
+                1: xy[1] + t,
+                width: width - (l + r),
+                height: height - (t + b)
+            };
+        }
+
+        box.left = box.x;
+        box.top = box.y;
+        box.right = box.x + box.width;
+        box.bottom = box.y + box.height;
+
+        return box;
+    },
+
+    
+    getPageBox: function(getRegion) {
+        var me = this,
+            el = me.dom,
+            w = el.offsetWidth,
+            h = el.offsetHeight,
+            xy = me.getXY(),
+            t = xy[1],
+            r = xy[0] + w,
+            b = xy[1] + h,
+            l = xy[0];
+
+        if (!el) {
+            return new Ext.util.Region();
+        }
+
+        if (getRegion) {
+            return new Ext.util.Region(t, r, b, l);
+        }
+        else {
+            return {
+                left: l,
+                top: t,
+                width: w,
+                height: h,
+                right: r,
+                bottom: b
+            };
+        }
+    }
+});
+
+}());
+
+//@tag dom,core
+
+//@require Ext.dom.AbstractElement-position
+
+//@define Ext.dom.AbstractElement-style
+
+//@define Ext.dom.AbstractElement
+
+
+
+(function(){
+    
+    var Element = Ext.dom.AbstractElement,
+        view = document.defaultView,
+        array = Ext.Array,
+        trimRe = /^\s+|\s+$/g,
+        wordsRe = /\w/g,
+        spacesRe = /\s+/,
+        transparentRe = /^(?:transparent|(?:rgba[(](?:\s*\d+\s*[,]){3}\s*0\s*[)]))$/i,
+        hasClassList = Ext.supports.ClassList,
+        PADDING = 'padding',
+        MARGIN = 'margin',
+        BORDER = 'border',
+        LEFT_SUFFIX = '-left',
+        RIGHT_SUFFIX = '-right',
+        TOP_SUFFIX = '-top',
+        BOTTOM_SUFFIX = '-bottom',
+        WIDTH = '-width',
+        
+        borders = {l: BORDER + LEFT_SUFFIX + WIDTH, r: BORDER + RIGHT_SUFFIX + WIDTH, t: BORDER + TOP_SUFFIX + WIDTH, b: BORDER + BOTTOM_SUFFIX + WIDTH},
+        paddings = {l: PADDING + LEFT_SUFFIX, r: PADDING + RIGHT_SUFFIX, t: PADDING + TOP_SUFFIX, b: PADDING + BOTTOM_SUFFIX},
+        margins = {l: MARGIN + LEFT_SUFFIX, r: MARGIN + RIGHT_SUFFIX, t: MARGIN + TOP_SUFFIX, b: MARGIN + BOTTOM_SUFFIX};
+
+
+    Element.override({
+
+        
+        styleHooks: {},
+
+        
+        addStyles : function(sides, styles){
+            var totalSize = 0,
+                sidesArr = (sides || '').match(wordsRe),
+                i,
+                len = sidesArr.length,
+                side,
+                styleSides = [];
+
+            if (len == 1) {
+                totalSize = Math.abs(parseFloat(this.getStyle(styles[sidesArr[0]])) || 0);
+            } else if (len) {
+                for (i = 0; i < len; i++) {
+                    side = sidesArr[i];
+                    styleSides.push(styles[side]);
+                }
+                
+                styleSides = this.getStyle(styleSides);
+
+                for (i=0; i < len; i++) {
+                    side = sidesArr[i];
+                    totalSize += Math.abs(parseFloat(styleSides[styles[side]]) || 0);
+                }
+            }
+
+            return totalSize;
+        },
+
+        
+        addCls: hasClassList ?
+            function (className) {
+                var me = this,
+                    dom = me.dom,
+                    classList,
+                    newCls,
+                    i,
+                    len,
+                    cls;
+
+                if (typeof(className) == 'string') {
+                    
+                    className = className.replace(trimRe, '').split(spacesRe);
+                }
+
+                
+                
+                if (dom && className && !!(len = className.length)) {
+                    if (!dom.className) {
+                        dom.className = className.join(' ');
+                    } else {
+                        classList = dom.classList;
+                        for (i = 0; i < len; ++i) {
+                            cls = className[i];
+                            if (cls) {
+                                if (!classList.contains(cls)) {
+                                    if (newCls) {
+                                        newCls.push(cls);
+                                    } else {
+                                        newCls = dom.className.replace(trimRe, '');
+                                        newCls = newCls ? [newCls, cls] : [cls];
+                                    }
+                                }
+                            }
+                        }
+
+                        if (newCls) {
+                            dom.className = newCls.join(' '); 
+                        }
+                    }
+                }
+                return me;
+            } :
+            function(className) {
+                var me = this,
+                    dom = me.dom,
+                    changed,
+                    elClasses;
+
+                if (dom && className && className.length) {
+                    elClasses = Ext.Element.mergeClsList(dom.className, className);
+                    if (elClasses.changed) {
+                        dom.className = elClasses.join(' '); 
+                    }
+                }
+                return me;
+            },
+
+
+        
+        removeCls: function(className) {
+            var me = this,
+                dom = me.dom,
+                len,
+                elClasses;
+
+            if (typeof(className) == 'string') {
+                
+                className = className.replace(trimRe, '').split(spacesRe);
+            }
+
+            if (dom && dom.className && className && !!(len = className.length)) {
+                if (len == 1 && hasClassList) {
+                    if (className[0]) {
+                        dom.classList.remove(className[0]); 
+                    }
+                } else {
+                    elClasses = Ext.Element.removeCls(dom.className, className);
+                    if (elClasses.changed) {
+                        dom.className = elClasses.join(' ');
+                    }
+                }
+            }
+            return me;
+        },
+
+        
+        radioCls: function(className) {
+            var cn = this.dom.parentNode.childNodes,
+                v,
+                i, len;
+            className = Ext.isArray(className) ? className: [className];
+            for (i = 0, len = cn.length; i < len; i++) {
+                v = cn[i];
+                if (v && v.nodeType == 1) {
+                    Ext.fly(v, '_internal').removeCls(className);
+                }
+            }
+            return this.addCls(className);
+        },
+
+        
+        toggleCls: hasClassList ?
+            function (className) {
+                var me = this,
+                    dom = me.dom;
+
+                if (dom) {
+                    className = className.replace(trimRe, '');
+                    if (className) {
+                        dom.classList.toggle(className);
+                    }
+                }
+
+                return me;
+            } :
+            function(className) {
+                var me = this;
+                return me.hasCls(className) ? me.removeCls(className) : me.addCls(className);
+            },
+
+        
+        hasCls: hasClassList ?
+            function (className) {
+                var dom = this.dom;
+                return (dom && className) ? dom.classList.contains(className) : false;
+            } :
+            function(className) {
+                var dom = this.dom;
+                return dom ? className && (' '+dom.className+' ').indexOf(' '+className+' ') != -1 : false;
+            },
+
+        
+        replaceCls: function(oldClassName, newClassName){
+            return this.removeCls(oldClassName).addCls(newClassName);
+        },
+
+        
+        isStyle: function(style, val) {
+            return this.getStyle(style) == val;
+        },
+
+        
+        getStyle: function (property, inline) {
+            var me = this,
+                dom = me.dom,
+                multiple = typeof property != 'string',
+                hooks = me.styleHooks,
+                prop = property,
+                props = prop,
+                len = 1,
+                domStyle, camel, values, hook, out, style, i;
+
+            if (multiple) {
+                values = {};
+                prop = props[0];
+                i = 0;
+                if (!(len = props.length)) {
+                    return values;
+                }
+            }
+
+            if (!dom || dom.documentElement) {
+                return values || '';
+            }
+
+            domStyle = dom.style;
+
+            if (inline) {
+                style = domStyle;
+            } else {
+                
+                
+                
+                
+                style = dom.ownerDocument.defaultView.getComputedStyle(dom, null);
+
+                
+                if (!style) {
+                    inline = true;
+                    style = domStyle;
+                }
+            }
+
+            do {
+                hook = hooks[prop];
+
+                if (!hook) {
+                    hooks[prop] = hook = { name: Element.normalize(prop) };
+                }
+
+                if (hook.get) {
+                    out = hook.get(dom, me, inline, style);
+                } else {
+                    camel = hook.name;
+                    out = style[camel];
+                }
+
+                if (!multiple) {
+                   return out;
+                }
+
+                values[prop] = out;
+                prop = props[++i];
+            } while (i < len);
+
+            return values;
+        },
+
+        getStyles: function () {
+            var props = Ext.Array.slice(arguments),
+                len = props.length,
+                inline;
+
+            if (len && typeof props[len-1] == 'boolean') {
+                inline = props.pop();
+            }
+
+            return this.getStyle(props, inline);
+        },
+
+        
+        isTransparent: function (prop) {
+            var value = this.getStyle(prop);
+            return value ? transparentRe.test(value) : false;
+        },
+
+        
+        setStyle: function(prop, value) {
+            var me = this,
+                dom = me.dom,
+                hooks = me.styleHooks,
+                style = dom.style,
+                name = prop,
+                hook;
+
+            
+            if (typeof name == 'string') {
+                hook = hooks[name];
+                if (!hook) {
+                    hooks[name] = hook = { name: Element.normalize(name) };
+                }
+                value = (value == null) ? '' : value;
+                if (hook.set) {
+                    hook.set(dom, value, me);
+                } else {
+                    style[hook.name] = value;
+                }
+                if (hook.afterSet) {
+                    hook.afterSet(dom, value, me);
+                }
+            } else {
+                for (name in prop) {
+                    if (prop.hasOwnProperty(name)) {
+                        hook = hooks[name];
+                        if (!hook) {
+                            hooks[name] = hook = { name: Element.normalize(name) };
+                        }
+                        value = prop[name];
+                        value = (value == null) ? '' : value;
+                        if (hook.set) {
+                            hook.set(dom, value, me);
+                        } else {
+                            style[hook.name] = value;
+                        }
+                        if (hook.afterSet) {
+                            hook.afterSet(dom, value, me);
+                        }
+                    }
+                }
+            }
+
+            return me;
+        },
+
+        
+        getHeight: function(contentHeight) {
+            var dom = this.dom,
+                height = contentHeight ? (dom.clientHeight - this.getPadding("tb")) : dom.offsetHeight;
+            return height > 0 ? height: 0;
+        },
+
+        
+        getWidth: function(contentWidth) {
+            var dom = this.dom,
+                width = contentWidth ? (dom.clientWidth - this.getPadding("lr")) : dom.offsetWidth;
+            return width > 0 ? width: 0;
+        },
+
+        
+        setWidth: function(width) {
+            var me = this;
+                me.dom.style.width = Element.addUnits(width);
+            return me;
+        },
+
+        
+        setHeight: function(height) {
+            var me = this;
+                me.dom.style.height = Element.addUnits(height);
+            return me;
+        },
+
+        
+        getBorderWidth: function(side){
+            return this.addStyles(side, borders);
+        },
+
+        
+        getPadding: function(side){
+            return this.addStyles(side, paddings);
+        },
+
+        margins : margins,
+
+        
+        applyStyles: function(styles) {
+            if (styles) {
+                var i,
+                    len,
+                    dom = this.dom;
+
+                if (typeof styles == 'function') {
+                    styles = styles.call();
+                }
+                if (typeof styles == 'string') {
+                    styles = Ext.util.Format.trim(styles).split(/\s*(?::|;)\s*/);
+                    for (i = 0, len = styles.length; i < len;) {
+                        dom.style[Element.normalize(styles[i++])] = styles[i++];
+                    }
+                }
+                else if (typeof styles == 'object') {
+                    this.setStyle(styles);
+                }
+            }
+        },
+
+        
+        setSize: function(width, height) {
+            var me = this,
+                style = me.dom.style;
+
+            if (Ext.isObject(width)) {
+                
+                height = width.height;
+                width = width.width;
+            }
+
+            style.width = Element.addUnits(width);
+            style.height = Element.addUnits(height);
+            return me;
+        },
+
+        
+        getViewSize: function() {
+            var doc = document,
+                dom = this.dom;
+
+            if (dom == doc || dom == doc.body) {
+                return {
+                    width: Element.getViewportWidth(),
+                    height: Element.getViewportHeight()
+                };
+            }
+            else {
+                return {
+                    width: dom.clientWidth,
+                    height: dom.clientHeight
+                };
+            }
+        },
+
+        
+        getSize: function(contentSize) {
+            var dom = this.dom;
+            return {
+                width: Math.max(0, contentSize ? (dom.clientWidth - this.getPadding("lr")) : dom.offsetWidth),
+                height: Math.max(0, contentSize ? (dom.clientHeight - this.getPadding("tb")) : dom.offsetHeight)
+            };
+        },
+
+        
+        repaint: function(){
+            var dom = this.dom;
+            this.addCls(Ext.baseCSSPrefix + 'repaint');
+            setTimeout(function(){
+                Ext.fly(dom).removeCls(Ext.baseCSSPrefix + 'repaint');
+            }, 1);
+            return this;
+        },
+
+        
+        getMargin: function(side){
+            var me = this,
+                hash = {t:"top", l:"left", r:"right", b: "bottom"},
+                key,
+                o,
+                margins;
+
+            if (!side) {
+                margins = [];
+                for (key in me.margins) {
+                    if(me.margins.hasOwnProperty(key)) {
+                        margins.push(me.margins[key]);
+                    }
+                }
+                o = me.getStyle(margins);
+                if(o && typeof o == 'object') {
+                    
+                    for (key in me.margins) {
+                        if(me.margins.hasOwnProperty(key)) {
+                            o[hash[key]] = parseFloat(o[me.margins[key]]) || 0;
+                        }
+                    }
+                }
+
+                return o;
+            } else {
+                return me.addStyles.call(me, side, me.margins);
+            }
+        },
+
+        
+        mask: function(msg, msgCls, transparent) {
+            var me = this,
+                dom = me.dom,
+                data = (me.$cache || me.getCache()).data,
+                el = data.mask,
+                mask,
+                size,
+                cls = '',
+                prefix = Ext.baseCSSPrefix;
+
+            me.addCls(prefix + 'masked');
+            if (me.getStyle("position") == "static") {
+                me.addCls(prefix + 'masked-relative');
+            }
+            if (el) {
+                el.remove();
+            }
+            if (msgCls && typeof msgCls == 'string' ) {
+                cls = ' ' + msgCls;
+            }
+            else {
+                cls = ' ' + prefix + 'mask-gray';
+            }
+
+            mask = me.createChild({
+                cls: prefix + 'mask' + ((transparent !== false) ? '' : (' ' + prefix + 'mask-gray')),
+                html: msg ? ('<div class="' + (msgCls || (prefix + 'mask-message')) + '">' + msg + '</div>') : ''
+            });
+
+            size = me.getSize();
+
+            data.mask = mask;
+
+            if (dom === document.body) {
+                size.height = window.innerHeight;
+                if (me.orientationHandler) {
+                    Ext.EventManager.unOrientationChange(me.orientationHandler, me);
+                }
+
+                me.orientationHandler = function() {
+                    size = me.getSize();
+                    size.height = window.innerHeight;
+                    mask.setSize(size);
+                };
+
+                Ext.EventManager.onOrientationChange(me.orientationHandler, me);
+            }
+            mask.setSize(size);
+            if (Ext.is.iPad) {
+                Ext.repaint();
+            }
+        },
+
+        
+        unmask: function() {
+            var me = this,
+                data = (me.$cache || me.getCache()).data,
+                mask = data.mask,
+                prefix = Ext.baseCSSPrefix;
+
+            if (mask) {
+                mask.remove();
+                delete data.mask;
+            }
+            me.removeCls([prefix + 'masked', prefix + 'masked-relative']);
+
+            if (me.dom === document.body) {
+                Ext.EventManager.unOrientationChange(me.orientationHandler, me);
+                delete me.orientationHandler;
+            }
+        }
+    });
+
+    
+    Element.populateStyleMap = function (map, order) {
+        var baseStyles = ['margin-', 'padding-', 'border-width-'],
+            beforeAfter = ['before', 'after'],
+            index, style, name, i;
+
+        for (index = baseStyles.length; index--; ) {
+            for (i = 2; i--; ) {
+                style = baseStyles[index] + beforeAfter[i]; 
+                
+                map[Element.normalize(style)] = map[style] = {
+                    name: Element.normalize(baseStyles[index] + order[i])
+                };
+            }
+        }
+    };
+
+    Ext.onReady(function () {
+        var supports = Ext.supports,
+            styleHooks,
+            colorStyles, i, name, camel;
+
+        function fixTransparent (dom, el, inline, style) {
+            var value = style[this.name] || '';
+            return transparentRe.test(value) ? 'transparent' : value;
+        }
+
+        function fixRightMargin (dom, el, inline, style) {
+            var result = style.marginRight,
+                domStyle, display;
+
+            
+            
+            if (result != '0px') {
+                domStyle = dom.style;
+                display = domStyle.display;
+                domStyle.display = 'inline-block';
+                result = (inline ? style : dom.ownerDocument.defaultView.getComputedStyle(dom, null)).marginRight;
+                domStyle.display = display;
+            }
+
+            return result;
+        }
+
+        function fixRightMarginAndInputFocus (dom, el, inline, style) {
+            var result = style.marginRight,
+                domStyle, cleaner, display;
+
+            if (result != '0px') {
+                domStyle = dom.style;
+                cleaner = Element.getRightMarginFixCleaner(dom);
+                display = domStyle.display;
+                domStyle.display = 'inline-block';
+                result = (inline ? style : dom.ownerDocument.defaultView.getComputedStyle(dom, '')).marginRight;
+                domStyle.display = display;
+                cleaner();
+            }
+
+            return result;
+        }
+
+        styleHooks = Element.prototype.styleHooks;
+
+        
+        Element.populateStyleMap(styleHooks, ['left', 'right']);
+
+        
+        
+        if (supports.init) {
+            supports.init();
+        }
+
+        
+        if (!supports.RightMargin) {
+            styleHooks.marginRight = styleHooks['margin-right'] = {
+                name: 'marginRight',
+                
+                
+                get: (supports.DisplayChangeInputSelectionBug || supports.DisplayChangeTextAreaSelectionBug) ?
+                        fixRightMarginAndInputFocus : fixRightMargin
+            };
+        }
+
+        if (!supports.TransparentColor) {
+            colorStyles = ['background-color', 'border-color', 'color', 'outline-color'];
+            for (i = colorStyles.length; i--; ) {
+                name = colorStyles[i];
+                camel = Element.normalize(name);
+
+                styleHooks[name] = styleHooks[camel] = {
+                    name: camel,
+                    get: fixTransparent
+                };
+            }
+        }
+    });
+}());
+
+//@tag dom,core
+
+//@require Ext.dom.AbstractElement-style
+
+//@define Ext.dom.AbstractElement-traversal
+
+//@define Ext.dom.AbstractElement
+
+
+
+Ext.dom.AbstractElement.override({
+    
+    findParent: function(simpleSelector, limit, returnEl) {
+        var target = this.dom,
+            topmost = document.documentElement,
+            depth = 0,
+            stopEl;
+
+        limit = limit || 50;
+        if (isNaN(limit)) {
+            stopEl = Ext.getDom(limit);
+            limit = Number.MAX_VALUE;
+        }
+        while (target && target.nodeType == 1 && depth < limit && target != topmost && target != stopEl) {
+            if (Ext.DomQuery.is(target, simpleSelector)) {
+                return returnEl ? Ext.get(target) : target;
+            }
+            depth++;
+            target = target.parentNode;
+        }
+        return null;
+    },
+
+    
+    findParentNode: function(simpleSelector, limit, returnEl) {
+        var p = Ext.fly(this.dom.parentNode, '_internal');
+        return p ? p.findParent(simpleSelector, limit, returnEl) : null;
+    },
+
+    
+    up: function(simpleSelector, limit) {
+        return this.findParentNode(simpleSelector, limit, true);
+    },
+
+    
+    select: function(selector, composite) {
+        return Ext.dom.Element.select(selector, this.dom, composite);
+    },
+
+    
+    query: function(selector) {
+        return Ext.DomQuery.select(selector, this.dom);
+    },
+
+    
+    down: function(selector, returnDom) {
+        var n = Ext.DomQuery.selectNode(selector, this.dom);
+        return returnDom ? n : Ext.get(n);
+    },
+
+    
+    child: function(selector, returnDom) {
+        var node,
+            me = this,
+            id;
+
+        
+        
+        id = Ext.id(me.dom);
+        
+        id = Ext.escapeId(id);
+        node = Ext.DomQuery.selectNode('#' + id + " > " + selector, me.dom);
+        return returnDom ? node : Ext.get(node);
+    },
+
+     
+    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) {
+        if (!this.dom) {
+            return null;
+        }
+
+        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;
+    },
+
+    isAncestor: function(element) {
+        return this.self.isAncestor.call(this.self, this.dom, element);
+    }
+});
+
+//@tag dom,core
+
+//@define Ext.DomHelper
+
+//@define Ext.core.DomHelper
+
+//@require Ext.dom.AbstractElement-traversal
+
+
+
+(function() {
+
+
+var afterbegin = 'afterbegin',
+    afterend = 'afterend',
+    beforebegin = 'beforebegin',
+    beforeend = 'beforeend',
+    ts = '<table>',
+    te = '</table>',
+    tbs = ts+'<tbody>',
+    tbe = '</tbody>'+te,
+    trs = tbs + '<tr>',
+    tre = '</tr>'+tbe,
+    detachedDiv = document.createElement('div'),
+    bbValues = ['BeforeBegin', 'previousSibling'],
+    aeValues = ['AfterEnd', 'nextSibling'],
+    bb_ae_PositionHash = {
+        beforebegin: bbValues,
+        afterend: aeValues
+    },
+    fullPositionHash = {
+        beforebegin: bbValues,
+        afterend: aeValues,
+        afterbegin: ['AfterBegin', 'firstChild'],
+        beforeend: ['BeforeEnd', 'lastChild']
+    };
+
+
+Ext.define('Ext.dom.Helper', {
+    extend: 'Ext.dom.AbstractHelper',
+    requires:['Ext.dom.AbstractElement'],
+
+    tableRe: /^table|tbody|tr|td$/i,
+
+    tableElRe: /td|tr|tbody/i,
+
+    
+    useDom : false,
+
+    
+    createDom: function(o, parentNode){
+        var el,
+            doc = document,
+            useSet,
+            attr,
+            val,
+            cn,
+            i, l;
+
+        if (Ext.isArray(o)) {                       
+            el = doc.createDocumentFragment(); 
+            for (i = 0, l = o.length; i < l; i++) {
+                this.createDom(o[i], el);
+            }
+        } else if (typeof o == 'string') {         
+            el = doc.createTextNode(o);
+        } else {
+            el = doc.createElement(o.tag || 'div');
+            useSet = !!el.setAttribute; 
+            for (attr in o) {
+                if (!this.confRe.test(attr)) {
+                    val = o[attr];
+                    if (attr == 'cls') {
+                        el.className = val;
+                    } else {
+                        if (useSet) {
+                            el.setAttribute(attr, val);
+                        } else {
+                            el[attr] = val;
+                        }
+                    }
+                }
+            }
+            Ext.DomHelper.applyStyles(el, o.style);
+
+            if ((cn = o.children || o.cn)) {
+                this.createDom(cn, el);
+            } else if (o.html) {
+                el.innerHTML = o.html;
+            }
+        }
+        if (parentNode) {
+            parentNode.appendChild(el);
+        }
+        return el;
+    },
+
+    ieTable: function(depth, openingTags, htmlContent, closingTags){
+        detachedDiv.innerHTML = [openingTags, htmlContent, closingTags].join('');
+
+        var i = -1,
+            el = detachedDiv,
+            ns;
+
+        while (++i < depth) {
+            el = el.firstChild;
+        }
+        
+        ns = el.nextSibling;
+
+        if (ns) {
+            el = document.createDocumentFragment();
+            while (ns) {
+                el.appendChild(ns);
+                ns = ns.nextSibling;
+            }
+        }
+        return el;
+    },
+
+    
+    insertIntoTable: function(tag, where, destinationEl, html) {
+        var node,
+            before,
+            bb = where == beforebegin,
+            ab = where == afterbegin,
+            be = where == beforeend,
+            ae = where == afterend;
+
+        if (tag == 'td' && (ab || be) || !this.tableElRe.test(tag) && (bb || ae)) {
+            return null;
+        }
+        before = bb ? destinationEl :
+                 ae ? destinationEl.nextSibling :
+                 ab ? destinationEl.firstChild : null;
+
+        if (bb || ae) {
+            destinationEl = destinationEl.parentNode;
+        }
+
+        if (tag == 'td' || (tag == 'tr' && (be || ab))) {
+            node = this.ieTable(4, trs, html, tre);
+        } else if ((tag == 'tbody' && (be || ab)) ||
+                (tag == 'tr' && (bb || ae))) {
+            node = this.ieTable(3, tbs, html, tbe);
+        } else {
+            node = this.ieTable(2, ts, html, te);
+        }
+        destinationEl.insertBefore(node, before);
+        return node;
+    },
+
+    
+    createContextualFragment: function(html) {
+        var fragment = document.createDocumentFragment(),
+            length, childNodes;
+
+        detachedDiv.innerHTML = html;
+        childNodes = detachedDiv.childNodes;
+        length = childNodes.length;
+
+        
+        while (length--) {
+            fragment.appendChild(childNodes[0]);
+        }
+        return fragment;
+    },
+
+    applyStyles: function(el, styles) {
+        if (styles) {
+            el = Ext.fly(el);
+            if (typeof styles == "function") {
+                styles = styles.call();
+            }
+            if (typeof styles == "string") {
+                styles = Ext.dom.Element.parseStyles(styles);
+            }
+            if (typeof styles == "object") {
+                el.setStyle(styles);
+            }
+        }
+    },
+
+    
+    createHtml: function(spec) {
+        return this.markup(spec);
+    },
+
+    doInsert: function(el, o, returnElement, pos, sibling, append) {
+        
+        el = el.dom || Ext.getDom(el);
+
+        var newNode;
+
+        if (this.useDom) {
+            newNode = this.createDom(o, null);
+
+            if (append) {
+                el.appendChild(newNode);
+            }
+            else {
+                (sibling == 'firstChild' ? el : el.parentNode).insertBefore(newNode, el[sibling] || el);
+            }
+
+        } else {
+            newNode = this.insertHtml(pos, el, this.markup(o));
+        }
+        return returnElement ? Ext.get(newNode, true) : newNode;
+    },
+
+    
+    overwrite: function(el, html, returnElement) {
+        var newNode;
+
+        el = Ext.getDom(el);
+        html = this.markup(html);
+
+        
+        if (Ext.isIE && this.tableRe.test(el.tagName)) {
+            
+            while (el.firstChild) {
+                el.removeChild(el.firstChild);
+            }
+            if (html) {
+                newNode = this.insertHtml('afterbegin', el, html);
+                return returnElement ? Ext.get(newNode) : newNode;
+            }
+            return null;
+        }
+        el.innerHTML = html;
+        return returnElement ? Ext.get(el.firstChild) : el.firstChild;
+    },
+
+    insertHtml: function(where, el, html) {
+        var hashVal,
+            range,
+            rangeEl,
+            setStart,
+            frag;
+
+        where = where.toLowerCase();
+
+        
+        if (el.insertAdjacentHTML) {
+
+            
+            if (Ext.isIE && this.tableRe.test(el.tagName) && (frag = this.insertIntoTable(el.tagName.toLowerCase(), where, el, html))) {
+                return frag;
+            }
+
+            if ((hashVal = fullPositionHash[where])) {
+                el.insertAdjacentHTML(hashVal[0], html);
+                return el[hashVal[1]];
+            }
+            
+        } else {
+            
+            if (el.nodeType === 3) {
+                where = where === 'afterbegin' ? 'beforebegin' : where;
+                where = where === 'beforeend' ? 'afterend' : where;
+            }
+            range = Ext.supports.CreateContextualFragment ? el.ownerDocument.createRange() : undefined;
+            setStart = 'setStart' + (this.endRe.test(where) ? 'After' : 'Before');
+            if (bb_ae_PositionHash[where]) {
+                if (range) {
+                    range[setStart](el);
+                    frag = range.createContextualFragment(html);
+                } else {
+                    frag = this.createContextualFragment(html);
+                }
+                el.parentNode.insertBefore(frag, where == beforebegin ? el : el.nextSibling);
+                return el[(where == beforebegin ? 'previous' : 'next') + 'Sibling'];
+            } else {
+                rangeEl = (where == afterbegin ? 'first' : 'last') + 'Child';
+                if (el.firstChild) {
+                    if (range) {
+                        range[setStart](el[rangeEl]);
+                        frag = range.createContextualFragment(html);
+                    } else {
+                        frag = this.createContextualFragment(html);
+                    }
+
+                    if (where == afterbegin) {
+                        el.insertBefore(frag, el.firstChild);
+                    } else {
+                        el.appendChild(frag);
+                    }
+                } else {
+                    el.innerHTML = html;
+                }
+                return el[rangeEl];
+            }
+        }
+    },
+
+    
+    createTemplate: function(o) {
+        var html = this.markup(o);
+        return new Ext.Template(html);
+    }
+
+}, function() {
+    Ext.ns('Ext.core');
+    Ext.DomHelper = Ext.core.DomHelper = new this;
+});
+
+
+}());
+
+//@tag dom,core
+
+//@require Helper.js
+
+//@define Ext.dom.Query
+
+//@define Ext.core.Query
+
+//@define Ext.DomQuery
+
+
+
+
+Ext.ns('Ext.core');
+
+Ext.dom.Query = Ext.core.DomQuery = Ext.DomQuery = (function(){
+    var cache = {},
+        simpleCache = {},
+        valueCache = {},
+        nonSpace = /\S/,
+        trimRe = /^\s+|\s+$/g,
+        tplRe = /\{(\d+)\}/g,
+        modeRe = /^(\s?[\/>+~]\s?|\s|$)/,
+        tagTokenRe = /^(#)?([\w\-\*\\]+)/,
+        nthRe = /(\d*)n\+?(\d*)/,
+        nthRe2 = /\D/,
+        startIdRe = /^\s*\#/,
+        
+        
+        
+        isIE = window.ActiveXObject ? true : false,
+        key = 30803,
+        longHex = /\\([0-9a-fA-F]{6})/g,
+        shortHex = /\\([0-9a-fA-F]{1,6})\s{0,1}/g,
+        nonHex = /\\([^0-9a-fA-F]{1})/g,
+        escapes = /\\/g,
+        num, hasEscapes,
+
+        
+        
+        longHexToChar = function($0, $1) {
+            return String.fromCharCode(parseInt($1, 16));
+        },
+
+        
+        shortToLongHex = function($0, $1) {
+            while ($1.length < 6) {
+                $1 = '0' + $1;
+            }
+            return '\\' + $1;
+        },
+
+        
+        charToLongHex = function($0, $1) {
+            num = $1.charCodeAt(0).toString(16);
+            if (num.length === 1) {
+                num = '0' + num;
+            }
+            return '\\0000' + num;
+        },
+
+        
+        
+        
+        unescapeCssSelector = function (selector) {
+            return (hasEscapes)
+                ? selector.replace(longHex, longHexToChar)
+                : selector;
+        },
+        
+        
+        setupEscapes = function(path){
+            hasEscapes = (path.indexOf('\\') > -1);
+            if (hasEscapes) {
+                path = path
+                    .replace(shortHex, shortToLongHex)
+                    .replace(nonHex, charToLongHex)
+                    .replace(escapes, '\\\\');  
+            }
+            return path;
+        };
+
+    
+    
+    eval("var batch = 30803;");
+
+    
+    
+    function child(parent, index){
+        var i = 0,
+            n = parent.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(parent){
+        var n = parent.firstChild,
+        nodeIndex = -1,
+        nextNode;
+        while(n){
+            nextNode = n.nextSibling;
+            
+            if(n.nodeType == 3 && !nonSpace.test(n.nodeValue)){
+                parent.removeChild(n);
+            }else{
+                
+                n.nodeIndex = ++nodeIndex;
+            }
+            n = nextNode;
+        }
+        return this;
+    }
+
+    
+    
+    function byClassName(nodeSet, cls){
+        cls = unescapeCssSelector(cls);
+        if(!cls){
+            return nodeSet;
+        }
+        var result = [], ri = -1,
+            i, ci;
+        for(i = 0, ci; ci = nodeSet[i]; i++){
+            if((' '+ci.className+' ').indexOf(cls) != -1){
+                result[++ri] = ci;
+            }
+        }
+        return result;
+    }
+
+    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,
+            i, ni, j, ci, cn, utag, n, cj;
+        if(!ns){
+            return result;
+        }
+        tagName = tagName || "*";
+        
+        if(typeof ns.getElementsByTagName != "undefined"){
+            ns = [ns];
+        }
+
+        
+        
+        if(!mode){
+            for(i = 0, ni; ni = ns[i]; i++){
+                cs = ni.getElementsByTagName(tagName);
+                for(j = 0, ci; ci = cs[j]; j++){
+                    result[++ri] = ci;
+                }
+            }
+        
+        
+        } else if(mode == "/" || mode == ">"){
+            utag = tagName.toUpperCase();
+            for(i = 0, ni, cn; ni = ns[i]; i++){
+                cn = ni.childNodes;
+                for(j = 0, cj; cj = cn[j]; j++){
+                    if(cj.nodeName == utag || cj.nodeName == tagName  || tagName == '*'){
+                        result[++ri] = cj;
+                    }
+                }
+            }
+        
+        
+        }else if(mode == "+"){
+            utag = tagName.toUpperCase();
+            for(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 == "~"){
+            utag = tagName.toUpperCase();
+            for(i = 0, n; n = ns[i]; i++){
+                while((n = n.nextSibling)){
+                    if (n.nodeName == utag || n.nodeName == tagName || tagName == '*'){
+                        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 result = [], ri = -1,
+            i, ci;
+        tagName = tagName.toLowerCase();
+        for(i = 0, ci; ci = cs[i]; i++){
+            if(ci.nodeType == 1 && ci.tagName.toLowerCase() == tagName){
+                result[++ri] = ci;
+            }
+        }
+        return result;
+    }
+
+    function byId(cs, id){
+        id = unescapeCssSelector(id);
+        if(cs.tagName || cs == document){
+            cs = [cs];
+        }
+        if(!id){
+            return cs;
+        }
+        var result = [], ri = -1,
+            i, ci;
+        for(i = 0, ci; ci = cs[i]; i++){
+            if(ci && ci.id == id){
+                result[++ri] = ci;
+                return result;
+            }
+        }
+        return result;
+    }
+
+    
+    
+    function byAttribute(cs, attr, value, op, custom){
+        var result = [],
+            ri = -1,
+            useGetStyle = custom == "{",
+            fn = Ext.DomQuery.operators[op],
+            a,
+            xml,
+            hasXml,
+            i, ci;
+
+        value = unescapeCssSelector(value);
+
+        for(i = 0, ci; ci = cs[i]; i++){
+            
+            if(ci.nodeType != 1){
+                continue;
+            }
+            
+            if(!hasXml){
+                xml = Ext.DomQuery.isXml(ci);
+                hasXml = true;
+            }
+
+            
+            if(!xml){
+                if(useGetStyle){
+                    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);
+                }
+            }else{
+                a = ci.getAttribute(attr);
+            }
+            if((fn && fn(a, value)) || (!fn && a)){
+                result[++ri] = ci;
+            }
+        }
+        return result;
+    }
+
+    function byPseudo(cs, name, value){
+        value = unescapeCssSelector(value);
+        return Ext.DomQuery.pseudos[name](cs, value);
+    }
+
+    function nodupIEXml(cs){
+        var d = ++key,
+            r,
+            i, len, c;
+        cs[0].setAttribute("_nodup", d);
+        r = [cs[0]];
+        for(i = 1, len = cs.length; i < len; i++){
+            c = cs[i];
+            if(!c.getAttribute("_nodup") != d){
+                c.setAttribute("_nodup", d);
+                r[r.length] = c;
+            }
+        }
+        for(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, d, j;
+        if(!len || typeof cs.nodeType != "undefined" || len == 1){
+            return cs;
+        }
+        if(isIE && typeof cs[0].selectSingleNode != "undefined"){
+            return nodupIEXml(cs);
+        }
+        d = ++key;
+        cs[0]._nodup = d;
+        for(i = 1; c = cs[i]; i++){
+            if(c._nodup != d){
+                c._nodup = d;
+            }else{
+                r = [];
+                for(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,
+            r = [],
+            i, len;
+        for(i = 0, len = c1.length; i < len; i++){
+            c1[i].setAttribute("_qdiff", d);
+        }
+        for(i = 0, len = c2.length; i < len; i++){
+            if(c2[i].getAttribute("_qdiff") != d){
+                r[r.length] = c2[i];
+            }
+        }
+        for(i = 0, len = c1.length; i < len; i++){
+           c1[i].removeAttribute("_qdiff");
+        }
+        return r;
+    }
+
+    function quickDiff(c1, c2){
+        var len1 = c1.length,
+            d = ++key,
+            r = [],
+            i, len;
+        if(!len1){
+            return c2;
+        }
+        if(isIE && typeof c1[0].selectSingleNode != "undefined"){
+            return quickDiffIEXml(c1, c2);
+        }
+        for(i = 0; i < len1; i++){
+            c1[i]._qdiff = d;
+        }
+        for(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){
+            id = unescapeCssSelector(id);
+            var d = root.ownerDocument || root;
+            return d.getElementById(id);
+        }
+        ns = getNodes(ns, mode, "*");
+        return byId(ns, 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"],
+                mode,
+                lastPath,
+                matchers = Ext.DomQuery.matchers,
+                matchersLn = matchers.length,
+                modeMatch,
+                
+                lmode = path.match(modeRe),
+                tokenMatch, matched, j, t, m;
+
+            path = setupEscapes(path);
+
+            if(lmode && lmode[1]){
+                fn[fn.length] = 'mode="'+lmode[1].replace(trimRe, "")+'";';
+                path = path.replace(lmode[1], "");
+            }
+
+            
+            while(path.substr(0, 1)=="/"){
+                path = path.substr(1);
+            }
+
+            while(path && lastPath != path){
+                lastPath = path;
+                tokenMatch = path.match(tagTokenRe);
+                if(type == "select"){
+                    if(tokenMatch){
+                        
+                        if(tokenMatch[1] == "#"){
+                            fn[fn.length] = 'n = quickId(n, mode, root, "'+tokenMatch[2]+'");';
+                        }else{
+                            fn[fn.length] = 'n = getNodes(n, mode, "'+tokenMatch[2]+'");';
+                        }
+                        path = path.replace(tokenMatch[0], "");
+                    }else if(path.substr(0, 1) != '@'){
+                        fn[fn.length] = 'n = getNodes(n, mode, "*");';
+                    }
+                
+                }else{
+                    if(tokenMatch){
+                        if(tokenMatch[1] == "#"){
+                            fn[fn.length] = 'n = byId(n, "'+tokenMatch[2]+'");';
+                        }else{
+                            fn[fn.length] = 'n = byTag(n, "'+tokenMatch[2]+'");';
+                        }
+                        path = path.replace(tokenMatch[0], "");
+                    }
+                }
+                while(!(modeMatch = path.match(modeRe))){
+                    matched = false;
+                    for(j = 0; j < matchersLn; j++){
+                        t = matchers[j];
+                        m = path.match(t.re);
+                        if(m){
+                            fn[fn.length] = t.select.replace(tplRe, function(x, i){
+                                return m[i];
+                            });
+                            path = path.replace(m[0], "");
+                            matched = true;
+                            break;
+                        }
+                    }
+                    
+                    if(!matched){
+                        Ext.Error.raise({
+                            sourceClass: 'Ext.DomQuery',
+                            sourceMethod: 'compile',
+                            msg: 'Error parsing selector. Parsing failed at "' + path + '"'
+                        });
+                    }
+                }
+                if(modeMatch[1]){
+                    fn[fn.length] = 'mode="'+modeMatch[1].replace(trimRe, "")+'";';
+                    path = path.replace(modeMatch[1], "");
+                }
+            }
+            
+            fn[fn.length] = "return nodup(n);\n}";
+
+            
+            eval(fn.join(""));
+            return f;
+        },
+
+        
+        jsSelect: function(path, root, type){
+            
+            root = root || document;
+
+            if(typeof root == "string"){
+                root = document.getElementById(root);
+            }
+            var paths = path.split(","),
+                results = [],
+                i, len, subPath, result;
+
+            
+            for(i = 0, len = paths.length; i < len; i++){
+                subPath = paths[i].replace(trimRe, "");
+                
+                if(!cache[subPath]){
+                    
+                    cache[subPath] = Ext.DomQuery.compile(subPath, type);
+                    if(!cache[subPath]){
+                        Ext.Error.raise({
+                            sourceClass: 'Ext.DomQuery',
+                            sourceMethod: 'jsSelect',
+                            msg: subPath + ' is not a valid selector'
+                        });
+                    }
+                } else {
+                    
+                    
+                    setupEscapes(subPath);
+                }
+                result = cache[subPath](root);
+                if(result && result != document){
+                    results = results.concat(result);
+                }
+            }
+
+            
+            
+            if(paths.length > 1){
+                return nodup(results);
+            }
+            return results;
+        },
+
+        isXml: function(el) {
+            var docEl = (el ? el.ownerDocument || el : 0).documentElement;
+            return docEl ? docEl.nodeName !== "HTML" : false;
+        },
+
+        
+        select : document.querySelectorAll ? function(path, root, type) {
+            root = root || document;
+            if (!Ext.DomQuery.isXml(root)) {
+                try {
+                    
+                    if (root.parentNode && (root.nodeType !== 9) && path.indexOf(',') === -1 && !startIdRe.test(path)) {
+                        path = '#' + Ext.escapeId(Ext.id(root)) + ' ' + path;
+                        root = root.parentNode;
+                    }
+                    return Ext.Array.toArray(root.querySelectorAll(path));
+                }
+                catch (e) {
+                }
+            }
+            return Ext.DomQuery.jsSelect.call(this, path, root, type);
+        } : function(path, root, type) {
+            return Ext.DomQuery.jsSelect.call(this, path, root, type);
+        },
+
+        
+        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");
+            } else {
+                setupEscapes(path);
+            }
+            
+            var n = valueCache[path](root), 
+                v;
+                
+            n = n[0] ? n[0] : n;
+
+            
+            
+            
+            
+            if (typeof n.normalize == 'function') {
+                n.normalize();
+            }
+
+            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),
+                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");
+            } else {
+                setupEscapes(ss);
+            }
+            
+            var result = simpleCache[ss](els);
+            return nonMatches ? quickDiff(result, els) : result;
+        },
+
+        
+        matchers : [{
+                re: /^\.([\w\-\\]+)/,
+                select: 'n = byClassName(n, " {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, "{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,
+                    i, ci;
+                for(i = 0; (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,
+                    i, ci;
+                for(i = 0; (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,
+                    m = nthRe.exec(a == "even" && "2n" || a == "odd" && "2n+1" || !nthRe2.test(a) && "n+" + a || a),
+                    f = (m[1] || 1) - 0, l = m[2] - 0,
+                    i, n, j, cn, pn;
+                for(i = 0; n = c[i]; i++){
+                    pn = n.parentNode;
+                    if (batch != pn._batch) {
+                        j = 0;
+                        for(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,
+                    i, ci;
+                for(i = 0; ci = c[i]; i++){
+                    if(!prev(ci) && !next(ci)){
+                        r[++ri] = ci;
+                    }
+                }
+                return r;
+            },
+
+            "empty" : function(c){
+                var r = [], ri = -1,
+                    i, ci, cns, j, cn, empty;
+                for(i = 0, ci; ci = c[i]; i++){
+                    cns = ci.childNodes;
+                    j = 0;
+                    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,
+                    i, ci;
+                for(i = 0; ci = c[i]; i++){
+                    if((ci.textContent||ci.innerText||ci.text||'').indexOf(v) != -1){
+                        r[++ri] = ci;
+                    }
+                }
+                return r;
+            },
+
+            "nodeValue" : function(c, v){
+                var r = [], ri = -1,
+                    i, ci;
+                for(i = 0; ci = c[i]; i++){
+                    if(ci.firstChild && ci.firstChild.nodeValue == v){
+                        r[++ri] = ci;
+                    }
+                }
+                return r;
+            },
+
+            "checked" : function(c){
+                var r = [], ri = -1,
+                    i, ci;
+                for(i = 0; 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('|'),
+                    r = [], ri = -1, s,
+                    i, ci, j;
+                for(i = 0; ci = c[i]; i++){
+                    for(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,
+                    r = [], ri = -1,
+                    i, ci;
+                for(i = 0; ci = c[i]; i++){
+                    if(s(ss, ci).length > 0){
+                        r[++ri] = ci;
+                    }
+                }
+                return r;
+            },
+
+            "next" : function(c, ss){
+                var is = Ext.DomQuery.is,
+                    r = [], ri = -1,
+                    i, ci, n;
+                for(i = 0; ci = c[i]; i++){
+                    n = next(ci);
+                    if(n && is(n, ss)){
+                        r[++ri] = ci;
+                    }
+                }
+                return r;
+            },
+
+            "prev" : function(c, ss){
+                var is = Ext.DomQuery.is,
+                    r = [], ri = -1,
+                    i, ci, n;
+                for(i = 0; ci = c[i]; i++){
+                    n = prev(ci);
+                    if(n && is(n, ss)){
+                        r[++ri] = ci;
+                    }
+                }
+                return r;
+            }
+        }
+    };
+}());
+
+
+Ext.query = Ext.DomQuery.select;
+
+
+//@tag dom,core
+
+//@require Query.js
+
+//@define Ext.dom.Element
+
+//@require Ext.dom.AbstractElement
+
+
+
+(function() {
+
+var HIDDEN = 'hidden',
+    DOC             = document,
+    VISIBILITY      = "visibility",
+    DISPLAY         = "display",
+    NONE            = "none",
+    XMASKED         = Ext.baseCSSPrefix + "masked",
+    XMASKEDRELATIVE = Ext.baseCSSPrefix + "masked-relative",
+    EXTELMASKMSG    = Ext.baseCSSPrefix + "mask-msg",
+    bodyRe          = /^body/i,
+    visFly,
+
+    
+    noBoxAdjust = Ext.isStrict ? {
+        select: 1
+    }: {
+        input: 1,
+        select: 1,
+        textarea: 1
+    },
+
+    
+    isScrolled = function(c) {
+        var r = [], ri = -1,
+            i, ci;
+        for (i = 0; ci = c[i]; i++) {
+            if (ci.scrollTop > 0 || ci.scrollLeft > 0) {
+                r[++ri] = ci;
+            }
+        }
+        return r;
+    },
+
+    Element = Ext.define('Ext.dom.Element', {
+
+    extend: 'Ext.dom.AbstractElement',
+
+    alternateClassName: ['Ext.Element', 'Ext.core.Element'],
+
+    addUnits: function() {
+        return this.self.addUnits.apply(this.self, arguments);
+    },
+
+    
+    focus: function(defer,  dom) {
+        var me = this,
+            scrollTop,
+            body;
+
+        dom = dom || me.dom;
+        body = (dom.ownerDocument || DOC).body || DOC.body;
+        try {
+            if (Number(defer)) {
+                Ext.defer(me.focus, defer, me, [null, dom]);
+            } else {
+                
+                
+                if (dom.offsetHeight > Element.getViewHeight()) {
+                    scrollTop = body.scrollTop;
+                }
+                dom.focus();
+                if (scrollTop !== undefined) {
+                    body.scrollTop = scrollTop;
+                }
+            }
+        } catch(e) {
+        }
+        return me;
+    },
+
+    
+    blur: function() {
+        try {
+            this.dom.blur();
+        } catch(e) {
+        }
+        return this;
+    },
+
+    
+    isBorderBox: function() {
+        var box = Ext.isBorderBox;
+        if (box) {
+            box = !((this.dom.tagName || "").toLowerCase() in noBoxAdjust);
+        }
+        return box;
+    },
+
+    
+    hover: function(overFn, outFn, scope, options) {
+        var me = this;
+        me.on('mouseenter', overFn, scope || me.dom, options);
+        me.on('mouseleave', outFn, scope || me.dom, options);
+        return me;
+    },
+
+    
+    getAttributeNS: function(ns, name) {
+        return this.getAttribute(name, ns);
+    },
+
+    getAttribute: (Ext.isIE && !(Ext.isIE9 && DOC.documentMode === 9)) ?
+        function(name, ns) {
+            var d = this.dom,
+                    type;
+            if (ns) {
+                type = typeof d[ns + ":" + name];
+                if (type != 'undefined' && type != 'unknown') {
+                    return d[ns + ":" + name] || null;
+                }
+                return null;
+            }
+            if (name === "for") {
+                name = "htmlFor";
+            }
+            return d[name] || null;
+        } : function(name, ns) {
+            var d = this.dom;
+            if (ns) {
+                return d.getAttributeNS(ns, name) || d.getAttribute(ns + ":" + name);
+            }
+            return  d.getAttribute(name) || d[name] || null;
+        },
+
+    
+    cacheScrollValues: function() {
+        var me = this,
+            scrolledDescendants,
+            el, i,
+            scrollValues = [],
+            result = function() {
+                for (i = 0; i < scrolledDescendants.length; i++) {
+                    el = scrolledDescendants[i];
+                    el.scrollLeft = scrollValues[i][0];
+                    el.scrollTop  = scrollValues[i][1];
+                }
+            };
+
+        if (!Ext.DomQuery.pseudos.isScrolled) {
+            Ext.DomQuery.pseudos.isScrolled = isScrolled;
+        }
+        scrolledDescendants = me.query(':isScrolled');
+        for (i = 0; i < scrolledDescendants.length; i++) {
+            el = scrolledDescendants[i];
+            scrollValues[i] = [el.scrollLeft, el.scrollTop];
+        }
+        return result;
+    },
+
+    
+    autoBoxAdjust: true,
+
+    
+    isVisible : function(deep) {
+        var me = this,
+            dom = me.dom,
+            stopNode = dom.ownerDocument.documentElement;
+
+        if (!visFly) {
+            visFly = new Element.Fly();
+        }
+
+        while (dom !== stopNode) {
+            
+            
+            if (!dom || dom.nodeType === 11 || (visFly.attach(dom)).isStyle(VISIBILITY, HIDDEN) || visFly.isStyle(DISPLAY, NONE)) {
+                return false;
+            }
+            
+            if (!deep) {
+                break;
+            }
+            dom = dom.parentNode;
+        }
+        return true;
+    },
+
+    
+    isDisplayed : function() {
+        return !this.isStyle(DISPLAY, NONE);
+    },
+
+    
+    enableDisplayMode : function(display) {
+        var me = this;
+        
+        me.setVisibilityMode(Element.DISPLAY);
+
+        if (!Ext.isEmpty(display)) {
+            (me.$cache || me.getCache()).data.originalDisplay = display;
+        }
+
+        return me;
+    },
+
+    
+    mask : function(msg, msgCls , elHeight) {
+        var me            = this,
+            dom           = me.dom,
+            
+            
+            setExpression = dom.style.setExpression,
+            data          = (me.$cache || me.getCache()).data,
+            maskEl        = data.maskEl,
+            maskMsg       = data.maskMsg;
+
+        if (!(bodyRe.test(dom.tagName) && me.getStyle('position') == 'static')) {
+            me.addCls(XMASKEDRELATIVE);
+        }
+        
+        
+        if (maskEl) {
+            maskEl.remove();
+        }
+        
+        if (maskMsg) {
+            maskMsg.remove();
+        }
+
+        Ext.DomHelper.append(dom, [{
+            cls : Ext.baseCSSPrefix + "mask"
+        }, {
+            cls : msgCls ? EXTELMASKMSG + " " + msgCls : EXTELMASKMSG,
+            cn  : {
+                tag: 'div',
+                html: msg || ''
+            }
+        }]);
+            
+        maskMsg = Ext.get(dom.lastChild);
+        maskEl = Ext.get(maskMsg.dom.previousSibling);
+        data.maskMsg = maskMsg;
+        data.maskEl = maskEl;
+
+        me.addCls(XMASKED);
+        maskEl.setDisplayed(true);
+
+        if (typeof msg == 'string') {
+            maskMsg.setDisplayed(true);
+            maskMsg.center(me);
+        } else {
+            maskMsg.setDisplayed(false);
+        }
+        
+        
+        
+        
+        
+        if (!Ext.supports.IncludePaddingInWidthCalculation && setExpression) {
+            
+            try {
+                maskEl.dom.style.setExpression('width', 'this.parentNode.clientWidth + "px"');
+            } catch (e) {}
+        }
+
+        
+        
+        if (!Ext.supports.IncludePaddingInHeightCalculation && setExpression) {
+            
+            try {
+                maskEl.dom.style.setExpression('height', 'this.parentNode.' + (dom == DOC.body ? 'scrollHeight' : 'offsetHeight') + ' + "px"');
+            } catch (e) {}
+        }
+        
+        else if (Ext.isIE && !(Ext.isIE7 && Ext.isStrict) && me.getStyle('height') == 'auto') {
+            maskEl.setSize(undefined, elHeight || me.getHeight());
+        }
+        return maskEl;
+    },
+
+    
+    unmask : function() {
+        var me      = this,
+            data    = (me.$cache || me.getCache()).data,
+            maskEl  = data.maskEl,
+            maskMsg = data.maskMsg,
+            style;
+
+        if (maskEl) {
+            style = maskEl.dom.style;
+            
+            if (style.clearExpression) {
+                style.clearExpression('width');
+                style.clearExpression('height');
+            }
+            
+            if (maskEl) {
+                maskEl.remove();
+                delete data.maskEl;
+            }
+            
+            if (maskMsg) {
+                maskMsg.remove();
+                delete data.maskMsg;
+            }
+            
+            me.removeCls([XMASKED, XMASKEDRELATIVE]);
+        }
+    },
+
+    
+    isMasked : function() {
+        var me      = this,
+            data    = (me.$cache || me.getCache()).data,
+            maskEl  = data.maskEl,
+            maskMsg = data.maskMsg,
+            hasMask = false; 
+
+        if (maskEl && maskEl.isVisible()) {
+            if (maskMsg) {
+                maskMsg.center(me);
+            }
+            hasMask = true;
+        }
+        return hasMask;
+    },
+
+    
+    createShim : function() {
+        var el = DOC.createElement('iframe'),
+            shim;
+
+        el.frameBorder = '0';
+        el.className = Ext.baseCSSPrefix + 'shim';
+        el.src = Ext.SSL_SECURE_URL;
+        shim = Ext.get(this.dom.parentNode.insertBefore(el, this.dom));
+        shim.autoBoxAdjust = false;
+        return shim;
+    },
+
+    
+    addKeyListener : function(key, fn, scope){
+        var config;
+        if(typeof key != 'object' || Ext.isArray(key)){
+            config = {
+                target: this,
+                key: key,
+                fn: fn,
+                scope: scope
+            };
+        }else{
+            config = {
+                target: this,
+                key : key.key,
+                shift : key.shift,
+                ctrl : key.ctrl,
+                alt : key.alt,
+                fn: fn,
+                scope: scope
+            };
+        }
+        return new Ext.util.KeyMap(config);
+    },
+
+    
+    addKeyMap : function(config) {
+        return new Ext.util.KeyMap(Ext.apply({
+            target: this
+        }, config));
+    },
+
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+
+    
+    
+    
+    
+
+    
+    
+    
+    
+    
+    
+    
+
+    
+    
+    
+    
+    
+    
+    
+
+    
+    
+    
+    
+
+    
+    
+    
+    
+    
+    
+    
+    
+
+    
+    on: function(eventName, fn, scope, options) {
+        Ext.EventManager.on(this, eventName, fn, scope || this, options);
+        return this;
+    },
+
+    
+    un: function(eventName, fn, scope) {
+        Ext.EventManager.un(this, eventName, fn, scope || this);
+        return this;
+    },
+
+    
+    removeAllListeners: function() {
+        Ext.EventManager.removeAll(this);
+        return this;
+    },
+
+    
+    purgeAllListeners: function() {
+        Ext.EventManager.purgeElement(this);
+        return this;
+    }
+
+}, function() {
+
+    var EC              = Ext.cache,
+        El              = this,
+        AbstractElement = Ext.dom.AbstractElement,
+        focusRe         = /a|button|embed|iframe|img|input|object|select|textarea/i,
+        nonSpaceRe      = /\S/,
+        scriptTagRe     = /(?:<script([^>]*)?>)((\n|\r|.)*?)(?:<\/script>)/ig,
+        replaceScriptTagRe = /(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)/ig,
+        srcRe           = /\ssrc=([\'\"])(.*?)\1/i,
+        typeRe          = /\stype=([\'\"])(.*?)\1/i,
+        useDocForId = !(Ext.isIE6 || Ext.isIE7 || Ext.isIE8);
+
+    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>';
+    
+
+    
+    
+    
+    function garbageCollect() {
+        if (!Ext.enableGarbageCollector) {
+            clearInterval(El.collectorThreadId);
+        } else {
+            var eid,
+                d,
+                o,
+                t;
+
+            for (eid in EC) {
+                if (!EC.hasOwnProperty(eid)) {
+                    continue;
+                }
+
+                o = EC[eid];
+
+                
+                if (o.skipGarbageCollection) {
+                    continue;
+                }
+
+                d = o.dom;
+
+
+                
+                
+                
+                
+                
+                
+                
+                
+                
+                
+                
+                
+                
+                
+                if (!d.parentNode || (!d.offsetParent && !Ext.getElementById(eid))) {
+                    if (d && Ext.enableListenerCollection) {
+                        Ext.EventManager.removeAll(d);
+                    }
+                    delete EC[eid];
+                }
+            }
+            
+            if (Ext.isIE) {
+                t = {};
+                for (eid in EC) {
+                    if (!EC.hasOwnProperty(eid)) {
+                        continue;
+                    }
+                    t[eid] = EC[eid];
+                }
+                EC = Ext.cache = t;
+            }
+        }
+    }
+
+    El.collectorThreadId = setInterval(garbageCollect, 30000);
+
+    
+    El.addMethods({
+
+        
+        monitorMouseLeave: function(delay, handler, scope) {
+            var me = this,
+                timer,
+                listeners = {
+                    mouseleave: function(e) {
+                        timer = setTimeout(Ext.Function.bind(handler, scope||me, [e]), delay);
+                    },
+                    mouseenter: function() {
+                        clearTimeout(timer);
+                    },
+                    freezeEvent: true
+                };
+
+            me.on(listeners);
+            return listeners;
+        },
+
+        
+        swallowEvent : function(eventName, preventDefault) {
+            var me = this,
+                e, eLen;
+            function fn(e) {
+                e.stopPropagation();
+                if (preventDefault) {
+                    e.preventDefault();
+                }
+            }
+
+            if (Ext.isArray(eventName)) {
+                eLen = eventName.length;
+
+                for (e = 0; e < eLen; e++) {
+                    me.on(eventName[e], fn);
+                }
+
+                return me;
+            }
+            me.on(eventName, fn);
+            return me;
+        },
+
+        
+        relayEvent : function(eventName, observable) {
+            this.on(eventName, function(e) {
+                observable.fireEvent(eventName, e);
+            });
+        },
+
+        
+        clean : function(forceReclean) {
+            var me   = this,
+                dom  = me.dom,
+                data = (me.$cache || me.getCache()).data,
+                n    = dom.firstChild,
+                ni   = -1,
+                nx;
+
+            if (data.isCleaned && forceReclean !== true) {
+                return me;
+            }
+
+            while (n) {
+                nx = n.nextSibling;
+                if (n.nodeType == 3) {
+                    
+                    if (!(nonSpaceRe.test(n.nodeValue))) {
+                        dom.removeChild(n);
+                    
+                    } else if (nx && nx.nodeType == 3) {
+                        n.appendData(Ext.String.trim(nx.data));
+                        dom.removeChild(nx);
+                        nx = n.nextSibling;
+                        n.nodeIndex = ++ni;
+                    }
+                } else {
+                    
+                    Ext.fly(n).clean();
+                    n.nodeIndex = ++ni;
+                }
+                n = nx;
+            }
+
+            data.isCleaned = true;
+            return me;
+        },
+
+        
+        load : function(options) {
+            this.getLoader().load(options);
+            return this;
+        },
+
+        
+        getLoader : function() {
+            var me = this,
+                data = (me.$cache || me.getCache()).data,
+                loader = data.loader;
+
+            if (!loader) {
+                data.loader = loader = new Ext.ElementLoader({
+                    target: me
+                });
+            }
+            return loader;
+        },
+
+        
+        syncContent: function(source) {
+            source = Ext.getDom(source);
+            var me = this,
+                sourceNodes = source.childNodes,
+                sourceLen = sourceNodes.length,
+                dest = me.dom,
+                destNodes = dest.childNodes,
+                destLen = destNodes.length,
+                i,  destNode, sourceNode,
+                nodeType;
+
+            
+            dest.style.cssText = source.style.cssText;
+            dest.className = source.className;
+
+            
+            if (sourceLen !== destLen) {
+                source.innerHTML = dest.innerHTML;
+                return;
+            }
+
+            
+            
+            for (i = 0; i < sourceLen; i++) {
+                sourceNode = sourceNodes[i];
+                destNode = destNodes[i];
+                nodeType = sourceNode.nodeType;
+
+                
+                if (nodeType !== destNode.nodeType || (nodeType === 1 && sourceNode.tagName !== destNode.tagName)) {
+                    dest.innerHTML = source.innerHTML;
+                    return;
+                }
+
+                
+                if (nodeType === 3) {
+                    destNode.data = sourceNode.data;
+                }
+                
+                else {
+                    if (sourceNode.id && destNode.id !== sourceNode.id) {
+                        destNode.id = sourceNode.id;
+                    }
+                    destNode.style.cssText = sourceNode.style.cssText;
+                    destNode.className = sourceNode.className;
+                    Ext.fly(destNode).syncContent(sourceNode);
+                }
+            }
+        },
+
+        
+        update : function(html, loadScripts, callback) {
+            var me = this,
+                id,
+                dom,
+                interval;
+
+            if (!me.dom) {
+                return me;
+            }
+            html = html || '';
+            dom = me.dom;
+
+            if (loadScripts !== true) {
+                dom.innerHTML = html;
+                Ext.callback(callback, me);
+                return me;
+            }
+
+            id  = Ext.id();
+            html += '<span id="' + id + '"></span>';
+
+            interval = setInterval(function() {
+                var hd,
+                    match,
+                    attrs,
+                    srcMatch,
+                    typeMatch,
+                    el,
+                    s;
+                if (!(el = DOC.getElementById(id))) {
+                    return false;
+                }
+                clearInterval(interval);
+                Ext.removeNode(el);
+                hd = Ext.getHead().dom;
+
+                while ((match = scriptTagRe.exec(html))) {
+                    attrs = match[1];
+                    srcMatch = attrs ? attrs.match(srcRe) : false;
+                    if (srcMatch && srcMatch[2]) {
+                       s = DOC.createElement("script");
+                       s.src = srcMatch[2];
+                       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]);
+                        }
+                    }
+                }
+                Ext.callback(callback, me);
+            }, 20);
+            dom.innerHTML = html.replace(replaceScriptTagRe, '');
+            return me;
+        },
+
+        
+        removeAllListeners : function() {
+            this.removeAnchor();
+            Ext.EventManager.removeAll(this.dom);
+            return this;
+        },
+
+        
+        createProxy : function(config, renderTo, matchBox) {
+            config = (typeof config == 'object') ? config : {tag : "div", cls: config};
+
+            var me = this,
+                proxy = renderTo ? Ext.DomHelper.append(renderTo, config, true) :
+                                   Ext.DomHelper.insertBefore(me.dom, config, true);
+
+            proxy.setVisibilityMode(Element.DISPLAY);
+            proxy.hide();
+            if (matchBox && me.setBox && me.getBox) { 
+               proxy.setBox(me.getBox());
+            }
+            return proxy;
+        },
+        
+        
+        getScopeParent: function() {
+            var parent = this.dom.parentNode;
+            if (Ext.scopeResetCSS) {
+                
+                parent = parent.parentNode;
+                if (!Ext.supports.CSS3LinearGradient || !Ext.supports.CSS3BorderRadius) {
+                    
+                    
+                    parent = parent.parentNode;
+                }
+            }
+            return parent;
+        },
+
+        
+        needsTabIndex: function() {
+            if (this.dom) {
+                if ((this.dom.nodeName === 'a') && (!this.dom.href)) {
+                    return true;
+                }
+                return !focusRe.test(this.dom.nodeName);
+            }
+        },
+
+        
+        focusable: function () {
+            var dom = this.dom,
+                nodeName = dom.nodeName,
+                canFocus = false;
+
+            if (!dom.disabled) {
+                if (focusRe.test(nodeName)) {
+                    if ((nodeName !== 'a') || dom.href) {
+                        canFocus = true;
+                    }
+                } else {
+                    canFocus = !isNaN(dom.tabIndex);
+                }
+            }
+            return canFocus && this.isVisible(true);
+        }
+    });
+
+    if (Ext.isIE) {
+        El.prototype.getById = function (id, asDom) {
+            var dom = this.dom,
+                cacheItem, el, ret;
+
+            if (dom) {
+                
+                
+                el = (useDocForId && DOC.getElementById(id)) || dom.all[id];
+                if (el) {
+                    if (asDom) {
+                        ret = el;
+                    } else {
+                        
+                        
+                        cacheItem = EC[id];
+                        if (cacheItem && cacheItem.el) {
+                            ret = Ext.updateCacheEntry(cacheItem, el).el;
+                        } else {
+                            ret = new Element(el);
+                        }
+                    }
+                    return ret;
+                }
+            }
+
+            return asDom ? Ext.getDom(id) : El.get(id);
+        };
+    }
+
+    El.createAlias({
+        
+        addListener: 'on',
+        
+        removeListener: 'un',
+        
+        clearListeners: 'removeAllListeners'
+    });
+
+    El.Fly = AbstractElement.Fly = new Ext.Class({
+        extend: El,
+
+        constructor: function(dom) {
+            this.dom = dom;
+        },
+        
+        attach: AbstractElement.Fly.prototype.attach
+    });
+
+    if (Ext.isIE) {
+        Ext.getElementById = function (id) {
+            var el = DOC.getElementById(id),
+                detachedBodyEl;
+
+            if (!el && (detachedBodyEl = AbstractElement.detachedBodyEl)) {
+                el = detachedBodyEl.dom.all[id];
+            }
+
+            return el;
+        };
+    } else if (!DOC.querySelector) {
+        Ext.getDetachedBody = Ext.getBody;
+
+        Ext.getElementById = function (id) {
+            return DOC.getElementById(id);
+        };
+    }
+});
+
+}());
+
+//@tag dom,core
+
+//@require Element.js
+
+//@define Ext.dom.Element-alignment
+
+//@define Ext.dom.Element
+
+
+
+Ext.dom.Element.override((function() {
+
+    var doc = document,
+        win = window,
+        alignRe = /^([a-z]+)-([a-z]+)(\?)?$/,
+        round = Math.round;
+
+    return {
+
+        
+        getAnchorXY: function(anchor, local, mySize) {
+            
+            
+            anchor = (anchor || "tl").toLowerCase();
+            mySize = mySize || {};
+
+            var me = this,
+                isViewport = me.dom == doc.body || me.dom == doc,
+                myWidth = mySize.width || isViewport ? Ext.dom.Element.getViewWidth() : me.getWidth(),
+                myHeight = mySize.height || isViewport ? Ext.dom.Element.getViewHeight() : me.getHeight(),
+                xy,
+                myPos = me.getXY(),
+                scroll = me.getScroll(),
+                extraX = isViewport ? scroll.left : !local ? myPos[0] : 0,
+                extraY = isViewport ? scroll.top : !local ? myPos[1] : 0;
+
+            
+            
+            switch (anchor) {
+                case 'tl' : xy = [ 0,                    0];
+                            break;
+                case 'bl' : xy = [ 0,                    myHeight];
+                            break;
+                case 'tr' : xy = [ myWidth,              0];
+                            break;
+                case 'c'  : xy = [ round(myWidth * 0.5), round(myHeight * 0.5)];
+                            break;
+                case 't'  : xy = [ round(myWidth * 0.5), 0];
+                            break;
+                case 'l'  : xy = [ 0,                    round(myHeight * 0.5)];
+                            break;
+                case 'r'  : xy = [ myWidth,              round(myHeight * 0.5)];
+                            break;
+                case 'b'  : xy = [ round(myWidth * 0.5), myHeight];
+                            break;
+                case 'br' : xy = [ myWidth,              myHeight];
+            }
+            return [xy[0] + extraX, xy[1] + extraY];
+        },
+
+        
+        getAlignToXY : function(alignToEl, posSpec, offset) {
+            alignToEl = Ext.get(alignToEl);
+
+            if (!alignToEl || !alignToEl.dom) {
+            }
+
+            offset = offset || [0,0];
+            posSpec = (!posSpec || posSpec == "?" ? "tl-bl?" : (!(/-/).test(posSpec) && posSpec !== "" ? "tl-" + posSpec : posSpec || "tl-bl")).toLowerCase();
+
+            var me = this,
+                    myPosition,
+                    alignToElPosition,
+                    x,
+                    y,
+                    myWidth,
+                    myHeight,
+                    alignToElRegion,
+                    viewportWidth = Ext.dom.Element.getViewWidth() - 10, 
+                    viewportHeight = Ext.dom.Element.getViewHeight() - 10, 
+                    p1y,
+                    p1x,
+                    p2y,
+                    p2x,
+                    swapY,
+                    swapX,
+                    docElement = doc.documentElement,
+                    docBody = doc.body,
+                    scrollX = (docElement.scrollLeft || docBody.scrollLeft || 0),
+                    scrollY = (docElement.scrollTop  || docBody.scrollTop  || 0),
+                    constrain, 
+                    align1,
+                    align2,
+                    alignMatch = posSpec.match(alignRe);
+
+
+            align1 = alignMatch[1];
+            align2 = alignMatch[2];
+            constrain = !!alignMatch[3];
+
+            
+            
+            myPosition = me.getAnchorXY(align1, true);
+            alignToElPosition = alignToEl.getAnchorXY(align2, false);
+
+            x = alignToElPosition[0] - myPosition[0] + offset[0];
+            y = alignToElPosition[1] - myPosition[1] + offset[1];
+
+            
+            if (constrain) {
+                myWidth = me.getWidth();
+                myHeight = me.getHeight();
+                alignToElRegion = alignToEl.getRegion();
+                
+                
+                
+                p1y = align1.charAt(0);
+                p1x = align1.charAt(align1.length - 1);
+                p2y = align2.charAt(0);
+                p2x = align2.charAt(align2.length - 1);
+                swapY = ((p1y == "t" && p2y == "b") || (p1y == "b" && p2y == "t"));
+                swapX = ((p1x == "r" && p2x == "l") || (p1x == "l" && p2x == "r"));
+
+                if (x + myWidth > viewportWidth + scrollX) {
+                    x = swapX ? alignToElRegion.left - myWidth : viewportWidth + scrollX - myWidth;
+                }
+                if (x < scrollX) {
+                    x = swapX ? alignToElRegion.right : scrollX;
+                }
+                if (y + myHeight > viewportHeight + scrollY) {
+                    y = swapY ? alignToElRegion.top - myHeight : viewportHeight + scrollY - myHeight;
+                }
+                if (y < scrollY) {
+                    y = swapY ? alignToElRegion.bottom : scrollY;
+                }
+            }
+            return [x,y];
+        },
+
+
+        
+        anchorTo : function(el, alignment, offsets, animate, monitorScroll, callback) {
+            var me = this,
+                dom = me.dom,
+                scroll = !Ext.isEmpty(monitorScroll),
+                action = function() {
+                    Ext.fly(dom).alignTo(el, alignment, offsets, animate);
+                    Ext.callback(callback, Ext.fly(dom));
+                },
+                anchor = this.getAnchor();
+
+            
+            this.removeAnchor();
+            Ext.apply(anchor, {
+                fn: action,
+                scroll: scroll
+            });
+
+            Ext.EventManager.onWindowResize(action, null);
+
+            if (scroll) {
+                Ext.EventManager.on(win, 'scroll', action, null,
+                        {buffer: !isNaN(monitorScroll) ? monitorScroll : 50});
+            }
+            action.call(me); 
+            return me;
+        },
+
+        
+        removeAnchor : function() {
+            var me = this,
+                anchor = this.getAnchor();
+
+            if (anchor && anchor.fn) {
+                Ext.EventManager.removeResizeListener(anchor.fn);
+                if (anchor.scroll) {
+                    Ext.EventManager.un(win, 'scroll', anchor.fn);
+                }
+                delete anchor.fn;
+            }
+            return me;
+        },
+
+        getAlignVector: function(el, spec, offset) {
+            var me = this,
+                myPos = me.getXY(),
+                alignedPos = me.getAlignToXY(el, spec, offset);
+
+            el = Ext.get(el);
+
+            alignedPos[0] -= myPos[0];
+            alignedPos[1] -= myPos[1];
+            return alignedPos;
+        },
+
+        
+        alignTo: function(element, position, offsets, animate) {
+            var me = this;
+            return me.setXY(me.getAlignToXY(element, position, offsets),
+                    me.anim && !!animate ? me.anim(animate) : false);
+        },
+
+        
+        getConstrainVector: function(constrainTo, proposedPosition) {
+            if (!(constrainTo instanceof Ext.util.Region)) {
+                constrainTo = Ext.get(constrainTo).getViewRegion();
+            }
+            var thisRegion = this.getRegion(),
+                    vector = [0, 0],
+                    shadowSize = (this.shadow && !this.shadowDisabled) ? this.shadow.getShadowSize() : undefined,
+                    overflowed = false;
+
+            
+            if (proposedPosition) {
+                thisRegion.translateBy(proposedPosition[0] - thisRegion.x, proposedPosition[1] - thisRegion.y);
+            }
+
+            
+            if (shadowSize) {
+                constrainTo.adjust(shadowSize[0], -shadowSize[1], -shadowSize[2], shadowSize[3]);
+            }
+
+            
+            if (thisRegion.right > constrainTo.right) {
+                overflowed = true;
+                vector[0] = (constrainTo.right - thisRegion.right);    
+            }
+            if (thisRegion.left + vector[0] < constrainTo.left) {
+                overflowed = true;
+                vector[0] = (constrainTo.left - thisRegion.left);      
+            }
+
+            
+            if (thisRegion.bottom > constrainTo.bottom) {
+                overflowed = true;
+                vector[1] = (constrainTo.bottom - thisRegion.bottom);  
+            }
+            if (thisRegion.top + vector[1] < constrainTo.top) {
+                overflowed = true;
+                vector[1] = (constrainTo.top - thisRegion.top);        
+            }
+            return overflowed ? vector : false;
+        },
+
+        
+        getCenterXY : function(){
+            return this.getAlignToXY(doc, 'c-c');
+        },
+
+        
+        center : function(centerIn){
+            return this.alignTo(centerIn || doc, 'c-c');
+        }
+    };
+}()));
+
+//@tag dom,core
+
+//@require Ext.dom.Element-alignment
+
+//@define Ext.dom.Element-anim
+
+//@define Ext.dom.Element
+
+
+
+
+
+Ext.dom.Element.override({
+    
+    animate: function(config) {
+        var me = this,
+            listeners,
+            anim,
+            animId = me.dom.id || Ext.id(me.dom);
+
+        if (!Ext.fx.Manager.hasFxBlock(animId)) {
+            
+            if (config.listeners) {
+                listeners = config.listeners;
+                delete config.listeners;
+            }
+            if (config.internalListeners) {
+                config.listeners = config.internalListeners;
+                delete config.internalListeners;
+            }
+            anim = new Ext.fx.Anim(me.anim(config));
+            if (listeners) {
+                anim.on(listeners);
+            }
+            Ext.fx.Manager.queueFx(anim);
+        }
+        return me;
+    },
+
+    
+    anim: function(config) {
+        if (!Ext.isObject(config)) {
+            return (config) ? {} : false;
+        }
+
+        var me = this,
+            duration = config.duration || Ext.fx.Anim.prototype.duration,
+            easing = config.easing || 'ease',
+            animConfig;
+
+        if (config.stopAnimation) {
+            me.stopAnimation();
+        }
+
+        Ext.applyIf(config, Ext.fx.Manager.getFxDefaults(me.id));
+
+        
+        Ext.fx.Manager.setFxDefaults(me.id, {
+            delay: 0
+        });
+
+        animConfig = {
+            
+            target: me.dom,
+            remove: config.remove,
+            alternate: config.alternate || false,
+            duration: duration,
+            easing: easing,
+            callback: config.callback,
+            listeners: config.listeners,
+            iterations: config.iterations || 1,
+            scope: config.scope,
+            block: config.block,
+            concurrent: config.concurrent,
+            delay: config.delay || 0,
+            paused: true,
+            keyframes: config.keyframes,
+            from: config.from || {},
+            to: Ext.apply({}, config)
+        };
+        Ext.apply(animConfig.to, config.to);
+
+        
+        delete animConfig.to.to;
+        delete animConfig.to.from;
+        delete animConfig.to.remove;
+        delete animConfig.to.alternate;
+        delete animConfig.to.keyframes;
+        delete animConfig.to.iterations;
+        delete animConfig.to.listeners;
+        delete animConfig.to.target;
+        delete animConfig.to.paused;
+        delete animConfig.to.callback;
+        delete animConfig.to.scope;
+        delete animConfig.to.duration;
+        delete animConfig.to.easing;
+        delete animConfig.to.concurrent;
+        delete animConfig.to.block;
+        delete animConfig.to.stopAnimation;
+        delete animConfig.to.delay;
+        return animConfig;
+    },
+
+    
+    slideIn: function(anchor, obj, slideOut) {
+        var me = this,
+            elStyle = me.dom.style,
+            beforeAnim,
+            wrapAnim,
+            restoreScroll,
+            wrapDomParentNode;
+
+        anchor = anchor || "t";
+        obj = obj || {};
+
+        beforeAnim = function() {
+            var animScope = this,
+                listeners = obj.listeners,
+                box, originalStyles, anim, wrap;
+
+            if (!slideOut) {
+                me.fixDisplay();
+            }
+
+            box = me.getBox();
+            if ((anchor == 't' || anchor == 'b') && box.height === 0) {
+                box.height = me.dom.scrollHeight;
+            }
+            else if ((anchor == 'l' || anchor == 'r') && box.width === 0) {
+                box.width = me.dom.scrollWidth;
+            }
+
+            originalStyles = me.getStyles('width', 'height', 'left', 'right', 'top', 'bottom', 'position', 'z-index', true);
+            me.setSize(box.width, box.height);
+
+            
+            if (obj.preserveScroll) {
+                restoreScroll = me.cacheScrollValues();
+            }
+
+            wrap = me.wrap({
+                id: Ext.id() + '-anim-wrap-for-' + me.id,
+                style: {
+                    visibility: slideOut ? 'visible' : 'hidden'
+                }
+            });
+            wrapDomParentNode = wrap.dom.parentNode;
+            wrap.setPositioning(me.getPositioning());
+            if (wrap.isStyle('position', 'static')) {
+                wrap.position('relative');
+            }
+            me.clearPositioning('auto');
+            wrap.clip();
+
+            
+            if (restoreScroll) {
+                restoreScroll();
+            }
+
+            
+            
+            
+            me.setStyle({
+                visibility: '',
+                position: 'absolute'
+            });
+            if (slideOut) {
+                wrap.setSize(box.width, box.height);
+            }
+
+            switch (anchor) {
+                case 't':
+                    anim = {
+                        from: {
+                            width: box.width + 'px',
+                            height: '0px'
+                        },
+                        to: {
+                            width: box.width + 'px',
+                            height: box.height + 'px'
+                        }
+                    };
+                    elStyle.bottom = '0px';
+                    break;
+                case 'l':
+                    anim = {
+                        from: {
+                            width: '0px',
+                            height: box.height + 'px'
+                        },
+                        to: {
+                            width: box.width + 'px',
+                            height: box.height + 'px'
+                        }
+                    };
+                    elStyle.right = '0px';
+                    break;
+                case 'r':
+                    anim = {
+                        from: {
+                            x: box.x + box.width,
+                            width: '0px',
+                            height: box.height + 'px'
+                        },
+                        to: {
+                            x: box.x,
+                            width: box.width + 'px',
+                            height: box.height + 'px'
+                        }
+                    };
+                    break;
+                case 'b':
+                    anim = {
+                        from: {
+                            y: box.y + box.height,
+                            width: box.width + 'px',
+                            height: '0px'
+                        },
+                        to: {
+                            y: box.y,
+                            width: box.width + 'px',
+                            height: box.height + 'px'
+                        }
+                    };
+                    break;
+                case 'tl':
+                    anim = {
+                        from: {
+                            x: box.x,
+                            y: box.y,
+                            width: '0px',
+                            height: '0px'
+                        },
+                        to: {
+                            width: box.width + 'px',
+                            height: box.height + 'px'
+                        }
+                    };
+                    elStyle.bottom = '0px';
+                    elStyle.right = '0px';
+                    break;
+                case 'bl':
+                    anim = {
+                        from: {
+                            y: box.y + box.height,
+                            width: '0px',
+                            height: '0px'
+                        },
+                        to: {
+                            y: box.y,
+                            width: box.width + 'px',
+                            height: box.height + 'px'
+                        }
+                    };
+                    elStyle.bottom = '0px';
+                    break;
+                case 'br':
+                    anim = {
+                        from: {
+                            x: box.x + box.width,
+                            y: box.y + box.height,
+                            width: '0px',
+                            height: '0px'
+                        },
+                        to: {
+                            x: box.x,
+                            y: box.y,
+                            width: box.width + 'px',
+                            height: box.height + 'px'
+                        }
+                    };
+                    break;
+                case 'tr':
+                    anim = {
+                        from: {
+                            x: box.x + box.width,
+                            width: '0px',
+                            height: '0px'
+                        },
+                        to: {
+                            x: box.x,
+                            width: box.width + 'px',
+                            height: box.height + 'px'
+                        }
+                    };
+                    elStyle.right = '0px';
+                    break;
+            }
+
+            wrap.show();
+            wrapAnim = Ext.apply({}, obj);
+            delete wrapAnim.listeners;
+            wrapAnim = new Ext.fx.Anim(Ext.applyIf(wrapAnim, {
+                target: wrap,
+                duration: 500,
+                easing: 'ease-out',
+                from: slideOut ? anim.to : anim.from,
+                to: slideOut ? anim.from : anim.to
+            }));
+
+            
+            wrapAnim.on('afteranimate', function() {
+                me.setStyle(originalStyles);
+                if (slideOut) {
+                    if (obj.useDisplay) {
+                        me.setDisplayed(false);
+                    } else {
+                        me.hide();
+                    }
+                }
+                if (wrap.dom) {
+                    if (wrap.dom.parentNode) {
+                        wrap.dom.parentNode.insertBefore(me.dom, wrap.dom);
+                    } else {
+                        wrapDomParentNode.appendChild(me.dom);
+                    }
+                    wrap.remove();
+                }
+                
+                if (restoreScroll) {
+                    restoreScroll();
+                }
+                
+                animScope.end();
+            });
+            
+            if (listeners) {
+                wrapAnim.on(listeners);
+            }
+        };
+
+        me.animate({
+            
+            duration: obj.duration ? Math.max(obj.duration, 500) * 2 : 1000,
+            listeners: {
+                beforeanimate: beforeAnim 
+            }
+        });
+        return me;
+    },
+
+
+    
+    slideOut: function(anchor, o) {
+        return this.slideIn(anchor, o, true);
+    },
+
+    
+    puff: function(obj) {
+        var me = this,
+            beforeAnim,
+            box = me.getBox(),
+            originalStyles = me.getStyles('width', 'height', 'left', 'right', 'top', 'bottom', 'position', 'z-index', 'font-size', 'opacity', true);
+
+       obj = Ext.applyIf(obj || {}, {
+            easing: 'ease-out',
+            duration: 500,
+            useDisplay: false
+        });
+
+        beforeAnim = function() {
+            me.clearOpacity();
+            me.show();
+            this.to = {
+                width: box.width * 2,
+                height: box.height * 2,
+                x: box.x - (box.width / 2),
+                y: box.y - (box.height /2),
+                opacity: 0,
+                fontSize: '200%'
+            };
+            this.on('afteranimate',function() {
+                if (me.dom) {
+                    if (obj.useDisplay) {
+                        me.setDisplayed(false);
+                    } else {
+                        me.hide();
+                    }
+                    me.setStyle(originalStyles);
+                    obj.callback.call(obj.scope);
+                }
+            });
+        };
+
+        me.animate({
+            duration: obj.duration,
+            easing: obj.easing,
+            listeners: {
+                beforeanimate: {
+                    fn: beforeAnim
+                }
+            }
+        });
+        return me;
+    },
+
+    
+    switchOff: function(obj) {
+        var me = this,
+            beforeAnim;
+
+        obj = Ext.applyIf(obj || {}, {
+            easing: 'ease-in',
+            duration: 500,
+            remove: false,
+            useDisplay: false
+        });
+
+        beforeAnim = function() {
+            var animScope = this,
+                size = me.getSize(),
+                xy = me.getXY(),
+                keyframe, position;
+            me.clearOpacity();
+            me.clip();
+            position = me.getPositioning();
+
+            keyframe = new Ext.fx.Animator({
+                target: me,
+                duration: obj.duration,
+                easing: obj.easing,
+                keyframes: {
+                    33: {
+                        opacity: 0.3
+                    },
+                    66: {
+                        height: 1,
+                        y: xy[1] + size.height / 2
+                    },
+                    100: {
+                        width: 1,
+                        x: xy[0] + size.width / 2
+                    }
+                }
+            });
+            keyframe.on('afteranimate', function() {
+                if (obj.useDisplay) {
+                    me.setDisplayed(false);
+                } else {
+                    me.hide();
+                }
+                me.clearOpacity();
+                me.setPositioning(position);
+                me.setSize(size);
+                
+                animScope.end();
+            });
+        };
+        
+        me.animate({
+            
+            duration: (Math.max(obj.duration, 500) * 2),
+            listeners: {
+                beforeanimate: {
+                    fn: beforeAnim
+                }
+            }
+        });
+        return me;
+    },
+
+    
+    frame : function(color, count, obj){
+        var me = this,
+            beforeAnim;
+
+        color = color || '#C3DAF9';
+        count = count || 1;
+        obj = obj || {};
+
+        beforeAnim = function() {
+            me.show();
+            var animScope = this,
+                box = me.getBox(),
+                proxy = Ext.getBody().createChild({
+                    id: me.id + '-anim-proxy',
+                    style: {
+                        position : 'absolute',
+                        'pointer-events': 'none',
+                        'z-index': 35000,
+                        border : '0px solid ' + color
+                    }
+                }),
+                proxyAnim;
+            proxyAnim = new Ext.fx.Anim({
+                target: proxy,
+                duration: obj.duration || 1000,
+                iterations: count,
+                from: {
+                    top: box.y,
+                    left: box.x,
+                    borderWidth: 0,
+                    opacity: 1,
+                    height: box.height,
+                    width: box.width
+                },
+                to: {
+                    top: box.y - 20,
+                    left: box.x - 20,
+                    borderWidth: 10,
+                    opacity: 0,
+                    height: box.height + 40,
+                    width: box.width + 40
+                }
+            });
+            proxyAnim.on('afteranimate', function() {
+                proxy.remove();
+                
+                animScope.end();
+            });
+        };
+
+        me.animate({
+            
+            duration: (Math.max(obj.duration, 500) * 2) || 2000,
+            listeners: {
+                beforeanimate: {
+                    fn: beforeAnim
+                }
+            }
+        });
+        return me;
+    },
+
+    
+    ghost: function(anchor, obj) {
+        var me = this,
+            beforeAnim;
+
+        anchor = anchor || "b";
+        beforeAnim = function() {
+            var width = me.getWidth(),
+                height = me.getHeight(),
+                xy = me.getXY(),
+                position = me.getPositioning(),
+                to = {
+                    opacity: 0
+                };
+            switch (anchor) {
+                case 't':
+                    to.y = xy[1] - height;
+                    break;
+                case 'l':
+                    to.x = xy[0] - width;
+                    break;
+                case 'r':
+                    to.x = xy[0] + width;
+                    break;
+                case 'b':
+                    to.y = xy[1] + height;
+                    break;
+                case 'tl':
+                    to.x = xy[0] - width;
+                    to.y = xy[1] - height;
+                    break;
+                case 'bl':
+                    to.x = xy[0] - width;
+                    to.y = xy[1] + height;
+                    break;
+                case 'br':
+                    to.x = xy[0] + width;
+                    to.y = xy[1] + height;
+                    break;
+                case 'tr':
+                    to.x = xy[0] + width;
+                    to.y = xy[1] - height;
+                    break;
+            }
+            this.to = to;
+            this.on('afteranimate', function () {
+                if (me.dom) {
+                    me.hide();
+                    me.clearOpacity();
+                    me.setPositioning(position);
+                }
+            });
+        };
+
+        me.animate(Ext.applyIf(obj || {}, {
+            duration: 500,
+            easing: 'ease-out',
+            listeners: {
+                beforeanimate: {
+                    fn: beforeAnim
+                }
+            }
+        }));
+        return me;
+    },
+
+    
+    highlight: function(color, o) {
+        var me = this,
+            dom = me.dom,
+            from = {},
+            restore, to, attr, lns, event, fn;
+
+        o = o || {};
+        lns = o.listeners || {};
+        attr = o.attr || 'backgroundColor';
+        from[attr] = color || 'ffff9c';
+
+        if (!o.to) {
+            to = {};
+            to[attr] = o.endColor || me.getColor(attr, 'ffffff', '');
+        }
+        else {
+            to = o.to;
+        }
+
+        
+        o.listeners = Ext.apply(Ext.apply({}, lns), {
+            beforeanimate: function() {
+                restore = dom.style[attr];
+                me.clearOpacity();
+                me.show();
+
+                event = lns.beforeanimate;
+                if (event) {
+                    fn = event.fn || event;
+                    return fn.apply(event.scope || lns.scope || window, arguments);
+                }
+            },
+            afteranimate: function() {
+                if (dom) {
+                    dom.style[attr] = restore;
+                }
+
+                event = lns.afteranimate;
+                if (event) {
+                    fn = event.fn || event;
+                    fn.apply(event.scope || lns.scope || window, arguments);
+                }
+            }
+        });
+
+        me.animate(Ext.apply({}, o, {
+            duration: 1000,
+            easing: 'ease-in',
+            from: from,
+            to: to
+        }));
+        return me;
+    },
+
+   
+    pause: function(ms) {
+        var me = this;
+        Ext.fx.Manager.setFxDefaults(me.id, {
+            delay: ms
+        });
+        return me;
+    },
+
+    
+    fadeIn: function(o) {
+        var me = this;
+        me.animate(Ext.apply({}, o, {
+            opacity: 1,
+            internalListeners: {
+                beforeanimate: function(anim){
+                    
+                    
+                    if (me.isStyle('display', 'none')) {
+                        me.setDisplayed('');
+                    } else {
+                        me.show();
+                    } 
+                }
+            }
+        }));
+        return this;
+    },
+
+    
+    fadeOut: function(o) {
+        var me = this;
+        o = Ext.apply({
+            opacity: 0,
+            internalListeners: {
+                afteranimate: function(anim){
+                    var dom = me.dom;
+                    if (dom && anim.to.opacity === 0) {
+                        if (o.useDisplay) {
+                            me.setDisplayed(false);
+                        } else {
+                            me.hide();
+                        }
+                    }         
+                }
+            }
+        }, o);
+        me.animate(o);
+        return me;
+    },
+
+    
+    scale: function(w, h, o) {
+        this.animate(Ext.apply({}, o, {
+            width: w,
+            height: h
+        }));
+        return this;
+    },
+
+    
+    shift: function(config) {
+        this.animate(config);
+        return this;
+    }
+});
+
+//@tag dom,core
+
+//@require Ext.dom.Element-anim
+
+//@define Ext.dom.Element-dd
+
+//@define Ext.dom.Element
+
+
+
+Ext.dom.Element.override({
+    
+    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);
+    }
+});
+
+//@tag dom,core
+
+//@require Ext.dom.Element-dd
+
+//@define Ext.dom.Element-fx
+
+//@define Ext.dom.Element
+
+
+
+(function() {
+
+var Element         = Ext.dom.Element,
+    VISIBILITY      = "visibility",
+    DISPLAY         = "display",
+    NONE            = "none",
+    HIDDEN          = 'hidden',
+    VISIBLE         = 'visible',
+    OFFSETS         = "offsets",
+    ASCLASS         = "asclass",
+    NOSIZE          = 'nosize',
+    ORIGINALDISPLAY = 'originalDisplay',
+    VISMODE         = 'visibilityMode',
+    ISVISIBLE       = 'isVisible',
+    OFFSETCLASS     = Ext.baseCSSPrefix + 'hide-offsets',
+    getDisplay = function(el) {
+        var data = (el.$cache || el.getCache()).data,
+            display = data[ORIGINALDISPLAY];
+            
+        if (display === undefined) {
+            data[ORIGINALDISPLAY] = display = '';
+        }
+        return display;
+    },
+    getVisMode = function(el){
+        var data = (el.$cache || el.getCache()).data,
+            visMode = data[VISMODE];
+            
+        if (visMode === undefined) {
+            data[VISMODE] = visMode = Element.VISIBILITY;
+        }
+        return visMode;
+    };
+
+Element.override({
+    
+    originalDisplay : "",
+    visibilityMode : 1,
+
+    
+    setVisible : function(visible, animate) {
+        var me = this,
+            dom = me.dom,
+            visMode = getVisMode(me);
+
+        
+        if (typeof animate == 'string') {
+            switch (animate) {
+                case DISPLAY:
+                    visMode = Element.DISPLAY;
+                    break;
+                case VISIBILITY:
+                    visMode = Element.VISIBILITY;
+                    break;
+                case OFFSETS:
+                    visMode = Element.OFFSETS;
+                    break;
+                case NOSIZE:
+                case ASCLASS:
+                    visMode = Element.ASCLASS;
+                    break;
+            }
+            me.setVisibilityMode(visMode);
+            animate = false;
+        }
+
+        if (!animate || !me.anim) {
+            if (visMode == Element.DISPLAY) {
+                return me.setDisplayed(visible);
+            } else if (visMode == Element.OFFSETS) {
+                me[visible?'removeCls':'addCls'](OFFSETCLASS);
+            } else if (visMode == Element.VISIBILITY) {
+                me.fixDisplay();
+                
+                dom.style.visibility = visible ? '' : HIDDEN;
+            } else if (visMode == Element.ASCLASS) {
+                me[visible?'removeCls':'addCls'](me.visibilityCls || Element.visibilityCls);
+            }
+        } else {
+            
+            if (visible) {
+                me.setOpacity(0.01);
+                me.setVisible(true);
+            }
+            if (!Ext.isObject(animate)) {
+                animate = {
+                    duration: 350,
+                    easing: 'ease-in'
+                };
+            }
+            me.animate(Ext.applyIf({
+                callback: function() {
+                    if (!visible) {
+                        me.setVisible(false).setOpacity(1);
+                    }
+                },
+                to: {
+                    opacity: (visible) ? 1 : 0
+                }
+            }, animate));
+        }
+        (me.$cache || me.getCache()).data[ISVISIBLE] = visible;
+        return me;
+    },
+
+    
+    hasMetrics  : function(){
+        var visMode = getVisMode(this);
+        return this.isVisible() || (visMode == Element.OFFSETS) || (visMode == Element.VISIBILITY);
+    },
+
+    
+    toggle : function(animate){
+        var me = this;
+        me.setVisible(!me.isVisible(), me.anim(animate));
+        return me;
+    },
+
+    
+    setDisplayed : function(value) {
+        if(typeof value == "boolean"){
+           value = value ? getDisplay(this) : NONE;
+        }
+        this.setStyle(DISPLAY, value);
+        return this;
+    },
+
+    
+    fixDisplay : function(){
+        var me = this;
+        if (me.isStyle(DISPLAY, NONE)) {
+            me.setStyle(VISIBILITY, HIDDEN);
+            me.setStyle(DISPLAY, getDisplay(me)); 
+            if (me.isStyle(DISPLAY, NONE)) { 
+                me.setStyle(DISPLAY, "block");
+            }
+        }
+    },
+
+    
+    hide : function(animate){
+        
+        if (typeof animate == 'string'){
+            this.setVisible(false, animate);
+            return this;
+        }
+        this.setVisible(false, this.anim(animate));
+        return this;
+    },
+
+    
+    show : function(animate){
+        
+        if (typeof animate == 'string'){
+            this.setVisible(true, animate);
+            return this;
+        }
+        this.setVisible(true, this.anim(animate));
+        return this;
+    }
+});
+
+}());
+
+//@tag dom,core
+
+//@require Ext.dom.Element-fx
+
+//@define Ext.dom.Element-position
+
+//@define Ext.dom.Element
+
+
+
+(function() {
+
+var Element = Ext.dom.Element,
+    LEFT = "left",
+    RIGHT = "right",
+    TOP = "top",
+    BOTTOM = "bottom",
+    POSITION = "position",
+    STATIC = "static",
+    RELATIVE = "relative",
+    AUTO = "auto",
+    ZINDEX = "z-index",
+    BODY = 'BODY',
+
+    PADDING = 'padding',
+    BORDER = 'border',
+    SLEFT = '-left',
+    SRIGHT = '-right',
+    STOP = '-top',
+    SBOTTOM = '-bottom',
+    SWIDTH = '-width',
+    
+    borders = {l: BORDER + SLEFT + SWIDTH, r: BORDER + SRIGHT + SWIDTH, t: BORDER + STOP + SWIDTH, b: BORDER + SBOTTOM + SWIDTH},
+    paddings = {l: PADDING + SLEFT, r: PADDING + SRIGHT, t: PADDING + STOP, b: PADDING + SBOTTOM},
+    paddingsTLRB = [paddings.l, paddings.r, paddings.t, paddings.b],
+    bordersTLRB = [borders.l,  borders.r,  borders.t,  borders.b],
+    positionTopLeft = ['position', 'top', 'left'];
+
+Element.override({
+
+    getX: function() {
+        return Element.getX(this.dom);
+    },
+
+    getY: function() {
+        return Element.getY(this.dom);
+    },
+
+    
+    getXY: function() {
+        return Element.getXY(this.dom);
+    },
+
+    
+    getOffsetsTo : function(el){
+        var o = this.getXY(),
+                e = Ext.fly(el, '_internal').getXY();
+        return [o[0] - e[0],o[1] - e[1]];
+    },
+
+    setX: function(x, animate) {
+        return this.setXY([x, this.getY()], animate);
+    },
+
+    setY: function(y, animate) {
+        return this.setXY([this.getX(), y], animate);
+    },
+
+    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) {
+        var me = this;
+        if (!animate || !me.anim) {
+            Element.setXY(me.dom, pos);
+        }
+        else {
+            if (!Ext.isObject(animate)) {
+                animate = {};
+            }
+            me.animate(Ext.applyIf({ to: { x: pos[0], y: pos[1] } }, animate));
+        }
+        return me;
+    },
+
+    pxRe: /^\d+(?:\.\d*)?px$/i,
+
+    
+    getLocalX: function() {
+        var me = this,
+            offsetParent,
+            x = me.getStyle(LEFT);
+
+        if (!x || x === AUTO) {
+            return 0;
+        }
+        if (x && me.pxRe.test(x)) {
+            return parseFloat(x);
+        }
+
+        x = me.getX();
+
+        offsetParent = me.dom.offsetParent;
+        if (offsetParent) {
+            x -= Ext.fly(offsetParent).getX();
+        }
+
+        return x;
+    },
+
+    
+    getLocalY: function() {
+        var me = this,
+            offsetParent,
+            y = me.getStyle(TOP);
+
+        if (!y || y === AUTO) {
+            return 0;
+        }
+        if (y && me.pxRe.test(y)) {
+            return parseFloat(y);
+        }
+
+        y = me.getY();
+
+        offsetParent = me.dom.offsetParent;
+        if (offsetParent) {
+            y -= Ext.fly(offsetParent).getY();
+        }
+
+        return y;
+    },
+
+    getLeft: function(local) {
+        return local ? this.getLocalX() : this.getX();
+    },
+
+    getRight: function(local) {
+        return (local ? this.getLocalX() : this.getX()) + this.getWidth();
+    },
+
+    getTop: function(local) {
+        return local ? this.getLocalY() : this.getY();
+    },
+
+    getBottom: function(local) {
+        return (local ? this.getLocalY() : this.getY()) + this.getHeight();
+    },
+
+    translatePoints: function(x, y) {
+        var me = this,
+            styles = me.getStyle(positionTopLeft),
+            relative = styles.position == 'relative',
+            left = parseFloat(styles.left),
+            top = parseFloat(styles.top),
+            xy = me.getXY();
+
+        if (Ext.isArray(x)) {
+             y = x[1];
+             x = x[0];
+        }
+        if (isNaN(left)) {
+            left = relative ? 0 : me.dom.offsetLeft;
+        }
+        if (isNaN(top)) {
+            top = relative ? 0 : me.dom.offsetTop;
+        }
+        left = (typeof x == 'number') ? x - xy[0] + left : undefined;
+        top = (typeof y == 'number') ? y - xy[1] + top : undefined;
+        return {
+            left: left,
+            top: top
+        };
+
+    },
+
+    setBox: function(box, adjust, animate) {
+        var me = this,
+                w = box.width,
+                h = box.height;
+        if ((adjust && !me.autoBoxAdjust) && !me.isBorderBox()) {
+            w -= (me.getBorderWidth("lr") + me.getPadding("lr"));
+            h -= (me.getBorderWidth("tb") + me.getPadding("tb"));
+        }
+        me.setBounds(box.x, box.y, w, h, animate);
+        return me;
+    },
+
+    getBox: function(contentBox, local) {
+        var me = this,
+            xy,
+            left,
+            top,
+            paddingWidth,
+            bordersWidth,
+            l, r, t, b, w, h, bx;
+
+        if (!local) {
+            xy = me.getXY();
+        } else {
+            xy = me.getStyle([LEFT, TOP]);
+            xy = [ parseFloat(xy.left) || 0, parseFloat(xy.top) || 0];
+        }
+        w = me.getWidth();
+        h = me.getHeight();
+        if (!contentBox) {
+            bx = {
+                x: xy[0],
+                y: xy[1],
+                0: xy[0],
+                1: xy[1],
+                width: w,
+                height: h
+            };
+        } else {
+            paddingWidth = me.getStyle(paddingsTLRB);
+            bordersWidth = me.getStyle(bordersTLRB);
+
+            l = (parseFloat(bordersWidth[borders.l]) || 0) + (parseFloat(paddingWidth[paddings.l]) || 0);
+            r = (parseFloat(bordersWidth[borders.r]) || 0) + (parseFloat(paddingWidth[paddings.r]) || 0);
+            t = (parseFloat(bordersWidth[borders.t]) || 0) + (parseFloat(paddingWidth[paddings.t]) || 0);
+            b = (parseFloat(bordersWidth[borders.b]) || 0) + (parseFloat(paddingWidth[paddings.b]) || 0);
+
+            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;
+    },
+
+    getPageBox: function(getRegion) {
+        var me = this,
+            el = me.dom,
+            isDoc = el.nodeName == BODY,
+            w = isDoc ? Ext.dom.AbstractElement.getViewWidth() : el.offsetWidth,
+            h = isDoc ? Ext.dom.AbstractElement.getViewHeight() : el.offsetHeight,
+            xy = me.getXY(),
+            t = xy[1],
+            r = xy[0] + w,
+            b = xy[1] + h,
+            l = xy[0];
+
+        if (getRegion) {
+            return new Ext.util.Region(t, r, b, l);
+        }
+        else {
+            return {
+                left: l,
+                top: t,
+                width: w,
+                height: h,
+                right: r,
+                bottom: b
+            };
+        }
+    },
+
+    
+    setLocation : function(x, y, animate) {
+        return this.setXY([x, y], animate);
+    },
+
+    
+    moveTo : function(x, y, animate) {
+        return this.setXY([x, y], animate);
+    },
+
+    
+    position : function(pos, zIndex, x, y) {
+        var me = this;
+
+        if (!pos && me.isStyle(POSITION, STATIC)) {
+            me.setStyle(POSITION, RELATIVE);
+        } else if (pos) {
+            me.setStyle(POSITION, pos);
+        }
+        if (zIndex) {
+            me.setStyle(ZINDEX, zIndex);
+        }
+        if (x || y) {
+            me.setXY([x || false, y || false]);
+        }
+    },
+
+    
+    clearPositioning : function(value) {
+        value = value || '';
+        this.setStyle({
+            left : value,
+            right : value,
+            top : value,
+            bottom : value,
+            "z-index" : "",
+            position : STATIC
+        });
+        return this;
+    },
+
+    
+    getPositioning : function(){
+        var styles = this.getStyle([LEFT, TOP, POSITION, RIGHT, BOTTOM, ZINDEX]);
+        styles[RIGHT] =  styles[LEFT] ? '' : styles[RIGHT];
+        styles[BOTTOM] = styles[TOP] ? '' : styles[BOTTOM];
+        return styles;
+    },
+
+    
+    setPositioning : function(pc) {
+        var me = this,
+            style = me.dom.style;
+
+        me.setStyle(pc);
+
+        if (pc.right == AUTO) {
+            style.right = "";
+        }
+        if (pc.bottom == AUTO) {
+            style.bottom = "";
+        }
+
+        return me;
+    },
+
+    
+    move: function(direction, distance, animate) {
+        var me = this,
+            xy = me.getXY(),
+            x = xy[0],
+            y = xy[1],
+            left = [x - distance, y],
+            right = [x + distance, y],
+            top = [x, y - distance],
+            bottom = [x, y + distance],
+            hash = {
+                l: left,
+                left: left,
+                r: right,
+                right: right,
+                t: top,
+                top: top,
+                up: top,
+                b: bottom,
+                bottom: bottom,
+                down: bottom
+            };
+
+        direction = direction.toLowerCase();
+        me.moveTo(hash[direction][0], hash[direction][1], animate);
+    },
+
+    
+    setLeftTop: function(left, top) {
+        var style = this.dom.style;
+
+        style.left = Element.addUnits(left);
+        style.top = Element.addUnits(top);
+
+        return this;
+    },
+
+    
+    getRegion: function() {
+        return this.getPageBox(true);
+    },
+
+    
+    getViewRegion: function() {
+        var me = this,
+            isBody = me.dom.nodeName == BODY,
+            scroll, pos, top, left, width, height;
+
+        
+        if (isBody) {
+            scroll = me.getScroll();
+            left = scroll.left;
+            top = scroll.top;
+            width = Ext.dom.AbstractElement.getViewportWidth();
+            height = Ext.dom.AbstractElement.getViewportHeight();
+        }
+        else {
+            pos = me.getXY();
+            left = pos[0] + me.getBorderWidth('l') + me.getPadding('l');
+            top = pos[1] + me.getBorderWidth('t') + me.getPadding('t');
+            width = me.getWidth(true);
+            height = me.getHeight(true);
+        }
+
+        return new Ext.util.Region(top, left + width - 1, top + height - 1, left);
+    },
+
+    
+    setBounds: function(x, y, width, height, animate) {
+        var me = this;
+        if (!animate || !me.anim) {
+            me.setSize(width, height);
+            me.setLocation(x, y);
+        } else {
+            if (!Ext.isObject(animate)) {
+                animate = {};
+            }
+            me.animate(Ext.applyIf({
+                to: {
+                    x: x,
+                    y: y,
+                    width: me.adjustWidth(width),
+                    height: me.adjustHeight(height)
+                }
+            }, animate));
+        }
+        return me;
+    },
+
+    
+    setRegion: function(region, animate) {
+        return this.setBounds(region.left, region.top, region.right - region.left, region.bottom - region.top, animate);
+    }
+});
+
+}());
+
+
+//@tag dom,core
+
+//@require Ext.dom.Element-position
+
+//@define Ext.dom.Element-scroll
+
+//@define Ext.dom.Element
+
+
+
+Ext.dom.Element.override({
+    
+    isScrollable: function() {
+        var dom = this.dom;
+        return dom.scrollHeight > dom.clientHeight || dom.scrollWidth > dom.clientWidth;
+    },
+
+    
+    getScroll: function() {
+        var d = this.dom,
+            doc = document,
+            body = doc.body,
+            docElement = doc.documentElement,
+            l,
+            t,
+            ret;
+
+        if (d == doc || d == body) {
+            if (Ext.isIE && Ext.isStrict) {
+                l = docElement.scrollLeft;
+                t = docElement.scrollTop;
+            } else {
+                l = window.pageXOffset;
+                t = window.pageYOffset;
+            }
+            ret = {
+                left: l || (body ? body.scrollLeft : 0),
+                top : t || (body ? body.scrollTop : 0)
+            };
+        } else {
+            ret = {
+                left: d.scrollLeft,
+                top : d.scrollTop
+            };
+        }
+
+        return ret;
+    },
+
+    
+    scrollBy: function(deltaX, deltaY, animate) {
+        var me = this,
+            dom = me.dom;
+
+        
+        if (deltaX.length) {
+            animate = deltaY;
+            deltaY = deltaX[1];
+            deltaX = deltaX[0];
+        } else if (typeof deltaX != 'number') { 
+            animate = deltaY;
+            deltaY = deltaX.y;
+            deltaX = deltaX.x;
+        }
+
+        if (deltaX) {
+            me.scrollTo('left', Math.max(Math.min(dom.scrollLeft + deltaX, dom.scrollWidth - dom.clientWidth), 0), animate);
+        }
+        if (deltaY) {
+            me.scrollTo('top', Math.max(Math.min(dom.scrollTop + deltaY, dom.scrollHeight - dom.clientHeight), 0), animate);
+        }
+
+        return me;
+    },
+
+    
+    scrollTo: function(side, value, animate) {
+        
+        var top = /top/i.test(side),
+            me = this,
+            dom = me.dom,
+            animCfg,
+            prop;
+
+        if (!animate || !me.anim) {
+            
+            prop = 'scroll' + (top ? 'Top' : 'Left');
+            dom[prop] = value;
+            
+            dom[prop] = value;
+        }
+        else {
+            animCfg = {
+                to: {}
+            };
+            animCfg.to['scroll' + (top ? 'Top' : 'Left')] = value;
+            if (Ext.isObject(animate)) {
+                Ext.applyIf(animCfg, animate);
+            }
+            me.animate(animCfg);
+        }
+        return me;
+    },
+
+    
+    scrollIntoView: function(container, hscroll, animate) {
+        container = Ext.getDom(container) || Ext.getBody().dom;
+        var el = this.dom,
+            offsets = this.getOffsetsTo(container),
+        
+            left = offsets[0] + container.scrollLeft,
+            top = offsets[1] + container.scrollTop,
+            bottom = top + el.offsetHeight,
+            right = left + el.offsetWidth,
+        
+            ctClientHeight = container.clientHeight,
+            ctScrollTop = parseInt(container.scrollTop, 10),
+            ctScrollLeft = parseInt(container.scrollLeft, 10),
+            ctBottom = ctScrollTop + ctClientHeight,
+            ctRight = ctScrollLeft + container.clientWidth,
+            newPos;
+
+        if (el.offsetHeight > ctClientHeight || top < ctScrollTop) {
+            newPos = top;
+        } else if (bottom > ctBottom) {
+            newPos = bottom - ctClientHeight;
+        }
+        if (newPos != null) {
+            Ext.get(container).scrollTo('top', newPos, animate);
+        }
+
+        if (hscroll !== false) {
+            newPos = null;
+            if (el.offsetWidth > container.clientWidth || left < ctScrollLeft) {
+                newPos = left;
+            } else if (right > ctRight) {
+                newPos = right - container.clientWidth;
+            }
+            if (newPos != null) {
+                Ext.get(container).scrollTo('left', newPos, animate);
+            }
+        }
+        return this;
+    },
+
+    
+    scrollChildIntoView: function(child, hscroll) {
+        Ext.fly(child, '_scrollChildIntoView').scrollIntoView(this, hscroll);
+    },
+
+    
+    scroll: function(direction, distance, animate) {
+        if (!this.isScrollable()) {
+            return false;
+        }
+        var el = this.dom,
+            l = el.scrollLeft, t = el.scrollTop,
+            w = el.scrollWidth, h = el.scrollHeight,
+            cw = el.clientWidth, ch = el.clientHeight,
+            scrolled = false, v,
+            hash = {
+                l: Math.min(l + distance, w - cw),
+                r: v = Math.max(l - distance, 0),
+                t: Math.max(t - distance, 0),
+                b: Math.min(t + distance, h - ch)
+            };
+
+        hash.d = hash.b;
+        hash.u = hash.t;
+
+        direction = direction.substr(0, 1);
+        if ((v = hash[direction]) > -1) {
+            scrolled = true;
+            this.scrollTo(direction == 'l' || direction == 'r' ? 'left' : 'top', v, this.anim(animate));
+        }
+        return scrolled;
+    }
+});
+
+//@tag dom,core
+
+//@require Ext.dom.Element-scroll
+
+//@define Ext.dom.Element-style
+
+//@define Ext.dom.Element
+
+
+
+(function() {
+
+var Element = Ext.dom.Element,
+    view = document.defaultView,
+    adjustDirect2DTableRe = /table-row|table-.*-group/,
+    INTERNAL = '_internal',
+    HIDDEN = 'hidden',
+    HEIGHT = 'height',
+    WIDTH = 'width',
+    ISCLIPPED = 'isClipped',
+    OVERFLOW = 'overflow',
+    OVERFLOWX = 'overflow-x',
+    OVERFLOWY = 'overflow-y',
+    ORIGINALCLIP = 'originalClip',
+    DOCORBODYRE = /#document|body/i,
+    
+    
+    styleHooks,
+    edges, k, edge, borderWidth;
+
+if (!view || !view.getComputedStyle) {
+    Element.prototype.getStyle = function (property, inline) {
+        var me = this,
+            dom = me.dom,
+            multiple = typeof property != 'string',
+            hooks = me.styleHooks,
+            prop = property,
+            props = prop,
+            len = 1,
+            isInline = inline,
+            camel, domStyle, values, hook, out, style, i;
+
+        if (multiple) {
+            values = {};
+            prop = props[0];
+            i = 0;
+            if (!(len = props.length)) {
+                return values;
+            }
+        }
+
+        if (!dom || dom.documentElement) {
+            return values || '';
+        }
+
+        domStyle = dom.style;
+
+        if (inline) {
+            style = domStyle;
+        } else {
+            style = dom.currentStyle;
+
+            
+            if (!style) {
+                isInline = true;
+                style = domStyle;
+            }
+        }
+
+        do {
+            hook = hooks[prop];
+
+            if (!hook) {
+                hooks[prop] = hook = { name: Element.normalize(prop) };
+            }
+
+            if (hook.get) {
+                out = hook.get(dom, me, isInline, style);
+            } else {
+                camel = hook.name;
+
+                
+                
+                
+                
+                if (hook.canThrow) {
+                    try {
+                        out = style[camel];
+                    } catch (e) {
+                        out = '';
+                    }
+                } else {
+                    
+                    
+                    out = style ? style[camel] : '';
+                }
+            }
+
+            if (!multiple) {
+                return out;
+            }
+
+            values[prop] = out;
+            prop = props[++i];
+        } while (i < len);
+
+        return values;
+    };
+}
+
+Element.override({
+    getHeight: function(contentHeight, preciseHeight) {
+        var me = this,
+            dom = me.dom,
+            hidden = me.isStyle('display', 'none'),
+            height,
+            floating;
+
+        if (hidden) {
+            return 0;
+        }
+
+        height = Math.max(dom.offsetHeight, dom.clientHeight) || 0;
+
+        
+        if (Ext.supports.Direct2DBug) {
+            floating = me.adjustDirect2DDimension(HEIGHT);
+            if (preciseHeight) {
+                height += floating;
+            }
+            else if (floating > 0 && floating < 0.5) {
+                height++;
+            }
+        }
+
+        if (contentHeight) {
+            height -= me.getBorderWidth("tb") + me.getPadding("tb");
+        }
+
+        return (height < 0) ? 0 : height;
+    },
+
+    getWidth: function(contentWidth, preciseWidth) {
+        var me = this,
+            dom = me.dom,
+            hidden = me.isStyle('display', 'none'),
+            rect, width, floating;
+
+        if (hidden) {
+            return 0;
+        }
+
+        
+        
+        
+        
+        
+        
+        if (Ext.supports.BoundingClientRect) {
+            rect = dom.getBoundingClientRect();
+            width = rect.right - rect.left;
+            width = preciseWidth ? width : Math.ceil(width);
+        } else {
+            width = dom.offsetWidth;
+        }
+
+        width = Math.max(width, dom.clientWidth) || 0;
+
+        
+        if (Ext.supports.Direct2DBug) {
+            
+            floating = me.adjustDirect2DDimension(WIDTH);
+            if (preciseWidth) {
+                width += floating;
+            }
+            
+            
+            
+            else if (floating > 0 && floating < 0.5) {
+                width++;
+            }
+        }
+
+        if (contentWidth) {
+            width -= me.getBorderWidth("lr") + me.getPadding("lr");
+        }
+
+        return (width < 0) ? 0 : width;
+    },
+
+    setWidth: function(width, animate) {
+        var me = this;
+        width = me.adjustWidth(width);
+        if (!animate || !me.anim) {
+            me.dom.style.width = me.addUnits(width);
+        }
+        else {
+            if (!Ext.isObject(animate)) {
+                animate = {};
+            }
+            me.animate(Ext.applyIf({
+                to: {
+                    width: width
+                }
+            }, animate));
+        }
+        return me;
+    },
+
+    setHeight : function(height, animate) {
+        var me = this;
+
+        height = me.adjustHeight(height);
+        if (!animate || !me.anim) {
+            me.dom.style.height = me.addUnits(height);
+        }
+        else {
+            if (!Ext.isObject(animate)) {
+                animate = {};
+            }
+            me.animate(Ext.applyIf({
+                to: {
+                    height: height
+                }
+            }, animate));
+        }
+
+        return me;
+    },
+
+    applyStyles: function(style) {
+        Ext.DomHelper.applyStyles(this.dom, style);
+        return this;
+    },
+
+    setSize: function(width, height, animate) {
+        var me = this;
+
+        if (Ext.isObject(width)) { 
+            animate = height;
+            height = width.height;
+            width = width.width;
+        }
+
+        width = me.adjustWidth(width);
+        height = me.adjustHeight(height);
+
+        if (!animate || !me.anim) {
+            me.dom.style.width = me.addUnits(width);
+            me.dom.style.height = me.addUnits(height);
+        }
+        else {
+            if (animate === true) {
+                animate = {};
+            }
+            me.animate(Ext.applyIf({
+                to: {
+                    width: width,
+                    height: height
+                }
+            }, animate));
+        }
+
+        return me;
+    },
+
+    getViewSize : function() {
+        var me = this,
+            dom = me.dom,
+            isDoc = DOCORBODYRE.test(dom.nodeName),
+            ret;
+
+        
+        if (isDoc) {
+            ret = {
+                width : Element.getViewWidth(),
+                height : Element.getViewHeight()
+            };
+        } else {
+            ret = {
+                width : dom.clientWidth,
+                height : dom.clientHeight
+            };
+        }
+
+        return ret;
+    },
+
+    getSize: function(contentSize) {
+        return {width: this.getWidth(contentSize), height: this.getHeight(contentSize)};
+    },
+
+    
+
+    
+    adjustWidth : function(width) {
+        var me = this,
+            isNum = (typeof width == 'number');
+
+        if (isNum && me.autoBoxAdjust && !me.isBorderBox()) {
+            width -= (me.getBorderWidth("lr") + me.getPadding("lr"));
+        }
+        return (isNum && width < 0) ? 0 : width;
+    },
+
+    
+    adjustHeight : function(height) {
+        var me = this,
+            isNum = (typeof height == "number");
+
+        if (isNum && me.autoBoxAdjust && !me.isBorderBox()) {
+            height -= (me.getBorderWidth("tb") + me.getPadding("tb"));
+        }
+        return (isNum && height < 0) ? 0 : height;
+    },
+
+    
+    getColor : function(attr, defaultValue, prefix) {
+        var v = this.getStyle(attr),
+            color = prefix || prefix === '' ? prefix : '#',
+            h, len, i=0;
+
+        if (!v || (/transparent|inherit/.test(v))) {
+            return defaultValue;
+        }
+        if (/^r/.test(v)) {
+             v = v.slice(4, v.length - 1).split(',');
+             len = v.length;
+             for (; i<len; i++) {
+                h = parseInt(v[i], 10);
+                color += (h < 16 ? '0' : '') + h.toString(16);
+            }
+        } else {
+            v = v.replace('#', '');
+            color += v.length == 3 ? v.replace(/^(\w)(\w)(\w)$/, '$1$1$2$2$3$3') : v;
+        }
+        return(color.length > 5 ? color.toLowerCase() : defaultValue);
+    },
+
+    
+    setOpacity: function(opacity, animate) {
+        var me = this;
+
+        if (!me.dom) {
+            return me;
+        }
+
+        if (!animate || !me.anim) {
+            me.setStyle('opacity', opacity);
+        }
+        else {
+            if (typeof animate != 'object') {
+                animate = {
+                    duration: 350,
+                    easing: 'ease-in'
+                };
+            }
+
+            me.animate(Ext.applyIf({
+                to: {
+                    opacity: opacity
+                }
+            }, animate));
+        }
+        return me;
+    },
+
+    
+    clearOpacity : function() {
+        return this.setOpacity('');
+    },
+
+    
+    adjustDirect2DDimension: function(dimension) {
+        var me = this,
+            dom = me.dom,
+            display = me.getStyle('display'),
+            inlineDisplay = dom.style.display,
+            inlinePosition = dom.style.position,
+            originIndex = dimension === WIDTH ? 0 : 1,
+            currentStyle = dom.currentStyle,
+            floating;
+
+        if (display === 'inline') {
+            dom.style.display = 'inline-block';
+        }
+
+        dom.style.position = display.match(adjustDirect2DTableRe) ? 'absolute' : 'static';
+
+        
+        
+        
+        
+        
+        floating = (parseFloat(currentStyle[dimension]) || parseFloat(currentStyle.msTransformOrigin.split(' ')[originIndex]) * 2) % 1;
+
+        dom.style.position = inlinePosition;
+
+        if (display === 'inline') {
+            dom.style.display = inlineDisplay;
+        }
+
+        return floating;
+    },
+
+    
+    clip : function() {
+        var me = this,
+            data = (me.$cache || me.getCache()).data,
+            style;
+
+        if (!data[ISCLIPPED]) {
+            data[ISCLIPPED] = true;
+            style = me.getStyle([OVERFLOW, OVERFLOWX, OVERFLOWY]);
+            data[ORIGINALCLIP] = {
+                o: style[OVERFLOW],
+                x: style[OVERFLOWX],
+                y: style[OVERFLOWY]
+            };
+            me.setStyle(OVERFLOW, HIDDEN);
+            me.setStyle(OVERFLOWX, HIDDEN);
+            me.setStyle(OVERFLOWY, HIDDEN);
+        }
+        return me;
+    },
+
+    
+    unclip : function() {
+        var me = this,
+            data = (me.$cache || me.getCache()).data,
+            clip;
+
+        if (data[ISCLIPPED]) {
+            data[ISCLIPPED] = false;
+            clip = data[ORIGINALCLIP];
+            if (clip.o) {
+                me.setStyle(OVERFLOW, clip.o);
+            }
+            if (clip.x) {
+                me.setStyle(OVERFLOWX, clip.x);
+            }
+            if (clip.y) {
+                me.setStyle(OVERFLOWY, clip.y);
+            }
+        }
+        return me;
+    },
+
+    
+    boxWrap : function(cls) {
+        cls = cls || Ext.baseCSSPrefix + 'box';
+        var el = Ext.get(this.insertHtml("beforeBegin", "<div class='" + cls + "'>" + Ext.String.format(Element.boxMarkup, cls) + "</div>"));
+        Ext.DomQuery.selectNode('.' + cls + '-mc', el.dom).appendChild(this.dom);
+        return el;
+    },
+
+    
+    getComputedHeight : function() {
+        var me = this,
+            h = Math.max(me.dom.offsetHeight, me.dom.clientHeight);
+        if (!h) {
+            h = parseFloat(me.getStyle(HEIGHT)) || 0;
+            if (!me.isBorderBox()) {
+                h += me.getFrameWidth('tb');
+            }
+        }
+        return h;
+    },
+
+    
+    getComputedWidth : function() {
+        var me = this,
+            w = Math.max(me.dom.offsetWidth, me.dom.clientWidth);
+
+        if (!w) {
+            w = parseFloat(me.getStyle(WIDTH)) || 0;
+            if (!me.isBorderBox()) {
+                w += me.getFrameWidth('lr');
+            }
+        }
+        return w;
+    },
+
+    
+    getFrameWidth : function(sides, onlyContentBox) {
+        return (onlyContentBox && this.isBorderBox()) ? 0 : (this.getPadding(sides) + this.getBorderWidth(sides));
+    },
+
+    
+    addClsOnOver : function(className, testFn, scope) {
+        var me = this,
+            dom = me.dom,
+            hasTest = Ext.isFunction(testFn);
+            
+        me.hover(
+            function() {
+                if (hasTest && testFn.call(scope || me, me) === false) {
+                    return;
+                }
+                Ext.fly(dom, INTERNAL).addCls(className);
+            },
+            function() {
+                Ext.fly(dom, INTERNAL).removeCls(className);
+            }
+        );
+        return me;
+    },
+
+    
+    addClsOnFocus : function(className, testFn, scope) {
+        var me = this,
+            dom = me.dom,
+            hasTest = Ext.isFunction(testFn);
+            
+        me.on("focus", function() {
+            if (hasTest && testFn.call(scope || me, me) === false) {
+                return false;
+            }
+            Ext.fly(dom, INTERNAL).addCls(className);
+        });
+        me.on("blur", function() {
+            Ext.fly(dom, INTERNAL).removeCls(className);
+        });
+        return me;
+    },
+
+    
+    addClsOnClick : function(className, testFn, scope) {
+        var me = this,
+            dom = me.dom,
+            hasTest = Ext.isFunction(testFn);
+            
+        me.on("mousedown", function() {
+            if (hasTest && testFn.call(scope || me, me) === false) {
+                return false;
+            }
+            Ext.fly(dom, INTERNAL).addCls(className);
+            var d = Ext.getDoc(),
+                fn = function() {
+                    Ext.fly(dom, INTERNAL).removeCls(className);
+                    d.removeListener("mouseup", fn);
+                };
+            d.on("mouseup", fn);
+        });
+        return me;
+    },
+
+    
+    getStyleSize : function() {
+        var me = this,
+            d = this.dom,
+            isDoc = DOCORBODYRE.test(d.nodeName),
+            s ,
+            w, h;
+
+        
+        if (isDoc) {
+            return {
+                width : Element.getViewWidth(),
+                height : Element.getViewHeight()
+            };
+        }
+
+        s = me.getStyle([HEIGHT, WIDTH], true);  
+        
+        if (s.width && s.width != 'auto') {
+            w = parseFloat(s.width);
+            if (me.isBorderBox()) {
+                w -= me.getFrameWidth('lr');
+            }
+        }
+        
+        if (s.height && s.height != 'auto') {
+            h = parseFloat(s.height);
+            if (me.isBorderBox()) {
+                h -= me.getFrameWidth('tb');
+            }
+        }
+        
+        return {width: w || me.getWidth(true), height: h || me.getHeight(true)};
+    },
+
+    
+    selectable : function() {
+        var me = this;
+        me.dom.unselectable = "off";
+        
+        me.on('selectstart', function (e) {
+            e.stopPropagation();
+            return true;
+        });
+        me.applyStyles("-moz-user-select: text; -khtml-user-select: text;");
+        me.removeCls(Ext.baseCSSPrefix + 'unselectable');
+        return me;
+    },
+
+    
+    unselectable : function() {
+        var me = this;
+        me.dom.unselectable = "on";
+
+        me.swallowEvent("selectstart", true);
+        me.applyStyles("-moz-user-select:-moz-none;-khtml-user-select:none;");
+        me.addCls(Ext.baseCSSPrefix + 'unselectable');
+
+        return me;
+    }
+});
+
+Element.prototype.styleHooks = styleHooks = Ext.dom.AbstractElement.prototype.styleHooks;
+
+if (Ext.isIE6 || Ext.isIE7) {
+    styleHooks.fontSize = styleHooks['font-size'] = {
+        name: 'fontSize',
+        canThrow: true
+    };
+    
+    styleHooks.fontStyle = styleHooks['font-style'] = {
+        name: 'fontStyle',
+        canThrow: true
+    };
+    
+    styleHooks.fontFamily = styleHooks['font-family'] = {
+        name: 'fontFamily',
+        canThrow: true
+    };
+}
+
+
+if (Ext.isIEQuirks || Ext.isIE && Ext.ieVersion <= 8) {
+    function getBorderWidth (dom, el, inline, style) {
+        if (style[this.styleName] == 'none') {
+            return '0px';
+        }
+        return style[this.name];
+    }
+
+    edges = ['Top','Right','Bottom','Left'];
+    k = edges.length;
+
+    while (k--) {
+        edge = edges[k];
+        borderWidth = 'border' + edge + 'Width';
+
+        styleHooks['border-'+edge.toLowerCase()+'-width'] = styleHooks[borderWidth] = {
+            name: borderWidth,
+            styleName: 'border' + edge + 'Style',
+            get: getBorderWidth
+        };
+    }
+}
+
+}());
+
+Ext.onReady(function () {
+    var opacityRe = /alpha\(opacity=(.*)\)/i,
+        trimRe = /^\s+|\s+$/g,
+        hooks = Ext.dom.Element.prototype.styleHooks;
+
+    
+    hooks.opacity = {
+        name: 'opacity',
+        afterSet: function(dom, value, el) {
+            if (el.isLayer) {
+                el.onOpacitySet(value);
+            }
+        }
+    };
+    if (!Ext.supports.Opacity && Ext.isIE) {
+        Ext.apply(hooks.opacity, {
+            get: function (dom) {
+                var filter = dom.style.filter,
+                    match, opacity;
+                if (filter.match) {
+                    match = filter.match(opacityRe);
+                    if (match) {
+                        opacity = parseFloat(match[1]);
+                        if (!isNaN(opacity)) {
+                            return opacity ? opacity / 100 : 0;
+                        }
+                    }
+                }
+                return 1;
+            },
+            set: function (dom, value) {
+                var style = dom.style,
+                    val = style.filter.replace(opacityRe, '').replace(trimRe, '');
+
+                style.zoom = 1; 
+
+                
+                if (typeof(value) == 'number' && value >= 0 && value < 1) {
+                    value *= 100;
+                    style.filter = val + (val.length ? ' ' : '') + 'alpha(opacity='+value+')';
+                } else {
+                    style.filter = val;
+                }
+            }  
+        });
+    }
+    
+    
+});
+
+//@tag dom,core
+
+//@require Ext.dom.Element-style
+
+//@define Ext.dom.Element-traversal
+
+//@define Ext.dom.Element
+
+
+
+Ext.dom.Element.override({
+    select: function(selector) {
+        return Ext.dom.Element.select(selector, false,  this.dom);
+    }
+});
+
+//@tag dom,core
+
+//@require Ext.dom.Element-traversal
+
+
+
+Ext.define('Ext.dom.CompositeElementLite', {
+    alternateClassName: 'Ext.CompositeElementLite',
+
+    requires: ['Ext.dom.Element', 'Ext.dom.Query'],
+
+    statics: {
+        
+        importElementMethods: function() {
+            var name,
+                elementPrototype = Ext.dom.Element.prototype,
+                prototype = this.prototype;
+
+            for (name in elementPrototype) {
+                if (typeof elementPrototype[name] == 'function'){
+                    (function(key) {
+                        prototype[key] = prototype[key] || function() {
+                            return this.invoke(key, arguments);
+                        };
+                    }).call(prototype, name);
+
+                }
+            }
+        }
+    },
+
+    constructor: function(elements, root) {
+        
+        this.elements = [];
+        this.add(elements, root);
+        this.el = new Ext.dom.AbstractElement.Fly();
+    },
+
+    
+    isComposite: true,
+
+    
+    getElement: function(el) {
+        
+        return this.el.attach(el);
+    },
+
+    
+    transformElement: function(el) {
+        return Ext.getDom(el);
+    },
+
+    
+    getCount: function() {
+        return this.elements.length;
+    },
+
+    
+    add: function(els, root) {
+        var elements = this.elements,
+            i, ln;
+
+        if (!els) {
+            return this;
+        }
+
+        if (typeof els == "string") {
+            els = Ext.dom.Element.selectorFunction(els, root);
+        }
+        else if (els.isComposite) {
+            els = els.elements;
+        }
+        else if (!Ext.isIterable(els)) {
+            els = [els];
+        }
+
+        for (i = 0, ln = els.length; i < ln; ++i) {
+            elements.push(this.transformElement(els[i]));
+        }
+
+        return this;
+    },
+
+    invoke: function(fn, args) {
+        var elements = this.elements,
+            ln = elements.length,
+            element,
+            i;
+
+        fn = Ext.dom.Element.prototype[fn];
+        for (i = 0; i < ln; i++) {
+            element = elements[i];
+
+            if (element) {
+                fn.apply(this.getElement(element), args);
+            }
+        }
+        return this;
+    },
+
+    
+    item: function(index) {
+        var el = this.elements[index],
+            out = null;
+
+        if (el) {
+            out = this.getElement(el);
+        }
+
+        return out;
+    },
+
+    
+    addListener: function(eventName, handler, scope, opt) {
+        var els = this.elements,
+                len = els.length,
+                i, e;
+
+        for (i = 0; i < len; i++) {
+            e = els[i];
+            if (e) {
+                Ext.EventManager.on(e, eventName, handler, scope || e, opt);
+            }
+        }
+        return this;
+    },
+    
+    each: function(fn, scope) {
+        var me  = this,
+            els = me.elements,
+            len = els.length,
+            i, e;
+
+        for (i = 0; i < len; i++) {
+            e = els[i];
+            if (e) {
+                e = this.getElement(e);
+                if (fn.call(scope || e, e, me, i) === false) {
+                    break;
+                }
+            }
+        }
+        return me;
+    },
+
+    
+    fill: function(els) {
+        var me = this;
+        me.elements = [];
+        me.add(els);
+        return me;
+    },
+
+    
+    filter: function(selector) {
+        var me  = this,
+            els = me.elements,
+            len = els.length,
+            out = [],
+            i = 0,
+            isFunc = typeof selector == 'function',
+            add,
+            el;
+
+        for (; i < len; i++) {
+            el = els[i];
+            add = false;
+            if (el) {
+                el = me.getElement(el);
+
+                if (isFunc) {
+                    add = selector.call(el, el, me, i) !== false;
+                } else {
+                    add = el.is(selector);
+                }
+                
+                if (add) {
+                    out.push(me.transformElement(el));
+                }
+            }
+        }
+
+        me.elements = out;
+        return me;
+    },
+
+    
+    indexOf: function(el) {
+        return Ext.Array.indexOf(this.elements, this.transformElement(el));
+    },
+
+    
+    replaceElement: function(el, replacement, domReplace) {
+        var index = !isNaN(el) ? el : this.indexOf(el),
+                d;
+        if (index > -1) {
+            replacement = Ext.getDom(replacement);
+            if (domReplace) {
+                d = this.elements[index];
+                d.parentNode.insertBefore(replacement, d);
+                Ext.removeNode(d);
+            }
+            Ext.Array.splice(this.elements, index, 1, replacement);
+        }
+        return this;
+    },
+
+    
+    clear: function() {
+        this.elements = [];
+    },
+
+    addElements: function(els, root) {
+        if (!els) {
+            return this;
+        }
+
+        if (typeof els == "string") {
+            els = Ext.dom.Element.selectorFunction(els, root);
+        }
+
+        var yels = this.elements,
+            eLen = els.length,
+            e;
+
+        for (e = 0; e < eLen; e++) {
+            yels.push(Ext.get(els[e]));
+        }
+
+        return this;
+    },
+
+    
+    first: function() {
+        return this.item(0);
+    },
+
+    
+    last: function() {
+        return this.item(this.getCount() - 1);
+    },
+
+    
+    contains: function(el) {
+        return this.indexOf(el) != -1;
+    },
+
+    
+    removeElement: function(keys, removeDom) {
+        keys = [].concat(keys);
+
+        var me       = this,
+            elements = me.elements,
+            kLen     = keys.length,
+            val, el, k;
+
+        for (k = 0; k < kLen; k++) {
+            val = keys[k];
+
+            if ((el = (elements[val] || elements[val = me.indexOf(val)]))) {
+                if (removeDom) {
+                    if (el.dom) {
+                        el.remove();
+                    } else {
+                        Ext.removeNode(el);
+                    }
+                }
+                Ext.Array.erase(elements, val, 1);
+            }
+        }
+
+        return me;
+    }
+
+}, function() {
+    this.importElementMethods();
+
+    this.prototype.on = this.prototype.addListener;
+
+    if (Ext.DomQuery){
+        Ext.dom.Element.selectorFunction = Ext.DomQuery.select;
+    }
+
+    
+   Ext.dom.Element.select = function(selector, root) {
+        var elements;
+
+        if (typeof selector == "string") {
+            elements = Ext.dom.Element.selectorFunction(selector, root);
+        }
+        else if (selector.length !== undefined) {
+            elements = selector;
+        }
+        else {
+        }
+
+        return new Ext.CompositeElementLite(elements);
+    };
+
+    
+    Ext.select = function() {
+        return Ext.dom.Element.select.apply(Ext.dom.Element, arguments);
+    };
+});
+
+
+Ext.define('Ext.util.Animate', {
+    requires: ['Ext.Element', 'Ext.CompositeElementLite'],
+    uses: ['Ext.fx.Manager', 'Ext.fx.Anim'],
+
+    
+    animate: function(animObj) {
+        var me = this;
+        if (Ext.fx.Manager.hasFxBlock(me.id)) {
+            return me;
+        }
+        Ext.fx.Manager.queueFx(new Ext.fx.Anim(me.anim(animObj)));
+        return this;
+    },
+
+    
+    anim: function(config) {
+        if (!Ext.isObject(config)) {
+            return (config) ? {} : false;
+        }
+
+        var me = this;
+
+        if (config.stopAnimation) {
+            me.stopAnimation();
+        }
+
+        Ext.applyIf(config, Ext.fx.Manager.getFxDefaults(me.id));
+
+        return Ext.apply({
+            target: me,
+            paused: true
+        }, config);
+    },
+
+    
+    stopFx: Ext.Function.alias(Ext.util.Animate, 'stopAnimation'),
+
+    
+    stopAnimation: function() {
+        Ext.fx.Manager.stopAnimation(this.id);
+        return this;
+    },
+
+    
+    syncFx: function() {
+        Ext.fx.Manager.setFxDefaults(this.id, {
+            concurrent: true
+        });
+        return this;
+    },
+
+    
+    sequenceFx: function() {
+        Ext.fx.Manager.setFxDefaults(this.id, {
+            concurrent: false
+        });
+        return this;
+    },
+
+    
+    hasActiveFx: Ext.Function.alias(Ext.util.Animate, 'getActiveAnimation'),
+
+    
+    getActiveAnimation: function() {
+        return Ext.fx.Manager.getActiveAnimation(this.id);
+    }
+}, function(){
+    
+    Ext.applyIf(Ext.Element.prototype, this.prototype);
+    
+    Ext.CompositeElementLite.importElementMethods();
+});
+
+
+Ext.define('Ext.util.ElementContainer', {
+
+    childEls: [
+        
+        
+        
+        
+    ],
+
+    constructor: function () {
+        var me = this,
+            childEls;
+
+        
+        
+        if (me.hasOwnProperty('childEls')) {
+            childEls = me.childEls;
+            delete me.childEls;
+
+            me.addChildEls.apply(me, childEls);
+        }
+    },
+
+    destroy: function () {
+        var me = this,
+            childEls = me.getChildEls(),
+            child, childName, i, k;
+
+        for (i = childEls.length; i--; ) {
+            childName = childEls[i];
+            if (typeof childName != 'string') {
+                childName = childName.name;
+            }
+
+            child = me[childName];
+            if (child) {
+                me[childName] = null; 
+                child.remove();
+            }
+        }
+    },
+
+    
+    addChildEls: function () {
+        var me = this,
+            args = arguments;
+
+        if (me.hasOwnProperty('childEls')) {
+            me.childEls.push.apply(me.childEls, args);
+        } else {
+            me.childEls = me.getChildEls().concat(Array.prototype.slice.call(args));
+        }
+        
+        me.prune(me.childEls, false);
+    },
+
+    
+    applyChildEls: function(el, id) {
+        var me = this,
+            childEls = me.getChildEls(),
+            baseId, childName, i, selector, value;
+
+        baseId = (id || me.id) + '-';
+        for (i = childEls.length; i--; ) {
+            childName = childEls[i];
+
+            if (typeof childName == 'string') {
+                
+                
+                value = el.getById(baseId + childName);
+            } else {
+                if ((selector = childName.select)) {
+                    value = Ext.select(selector, true, el.dom); 
+                } else if ((selector = childName.selectNode)) {
+                    value = Ext.get(Ext.DomQuery.selectNode(selector, el.dom));
+                } else {
+                    
+                    value = el.getById(childName.id || (baseId + childName.itemId));
+                }
+
+                childName = childName.name;
+            }
+
+            me[childName] = value;
+        }
+    },
+
+    getChildEls: function () {
+        var me = this,
+            self;
+
+        
+        if (me.hasOwnProperty('childEls')) {
+            return me.childEls;
+        }
+
+        
+        
+        self = me.self;
+        return self.$childEls || me.getClassChildEls(self);
+    },
+
+    getClassChildEls: function (cls) {
+        var me = this,
+            result = cls.$childEls,
+            childEls, i, length, forked, mixin, mixins, name, parts, proto, supr, superMixins;
+
+        if (!result) {
+            
+            
+            
+
+            supr = cls.superclass;
+            if (supr) {
+                supr = supr.self;
+                parts = [supr.$childEls || me.getClassChildEls(supr)]; 
+                superMixins = supr.prototype.mixins || {};
+            } else {
+                parts = [];
+                superMixins = {};
+            }
+
+            proto = cls.prototype;
+            mixins = proto.mixins; 
+            for (name in mixins) {
+                if (mixins.hasOwnProperty(name) && !superMixins.hasOwnProperty(name)) {
+                    mixin = mixins[name].self;
+                    parts.push(mixin.$childEls || me.getClassChildEls(mixin));
+                }
+            }
+
+            parts.push(proto.hasOwnProperty('childEls') && proto.childEls);
+
+            for (i = 0, length = parts.length; i < length; ++i) {
+                childEls = parts[i];
+                if (childEls && childEls.length) {
+                    if (!result) {
+                        result = childEls;
+                    } else {
+                        if (!forked) {
+                            forked = true;
+                            result = result.slice(0);
+                        }
+                        result.push.apply(result, childEls);
+                    }
+                }
+            }
+
+            cls.$childEls = result = (result ? me.prune(result, !forked) : []);
+        }
+
+        return result;
+    },
+
+    prune: function (childEls, shared) {
+        var index = childEls.length,
+            map = {},
+            name;
+
+        while (index--) {
+            name = childEls[index];
+            if (typeof name != 'string') {
+                name = name.name;
+            }
+
+            if (!map[name]) {
+                map[name] = 1;
+            } else {
+                if (shared) {
+                    shared = false;
+                    childEls = childEls.slice(0);
+                }
+                Ext.Array.erase(childEls, index, 1);
+            }
+        }
+
+        return childEls;
+    },
+
+    
+    removeChildEls: function (testFn) {
+        var me = this,
+            old = me.getChildEls(),
+            keepers = (me.childEls = []),
+            n, i, cel;
+
+        for (i = 0, n = old.length; i < n; ++i) {
+            cel = old[i];
+            if (!testFn(cel)) {
+                keepers.push(cel);
+            }
+        }
+    }
+});
+
+
+Ext.define('Ext.util.Renderable', {
+    requires: [
+        'Ext.dom.Element'
+    ],
+
+    frameCls: Ext.baseCSSPrefix + 'frame',
+
+    frameIdRegex: /[\-]frame\d+[TMB][LCR]$/,
+
+    frameElementCls: {
+        tl: [],
+        tc: [],
+        tr: [],
+        ml: [],
+        mc: [],
+        mr: [],
+        bl: [],
+        bc: [],
+        br: []
+    },
+
+    frameElNames: ['TL','TC','TR','ML','MC','MR','BL','BC','BR'],
+
+    frameTpl: [
+        '{%this.renderDockedItems(out,values,0);%}',
+        '<tpl if="top">',
+            '<tpl if="left"><div id="{fgid}TL" class="{frameCls}-tl {baseCls}-tl {baseCls}-{ui}-tl<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-tl</tpl>" style="background-position: {tl}; padding-left: {frameWidth}px" role="presentation"></tpl>',
+                '<tpl if="right"><div id="{fgid}TR" class="{frameCls}-tr {baseCls}-tr {baseCls}-{ui}-tr<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-tr</tpl>" style="background-position: {tr}; padding-right: {frameWidth}px" role="presentation"></tpl>',
+                    '<div id="{fgid}TC" class="{frameCls}-tc {baseCls}-tc {baseCls}-{ui}-tc<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-tc</tpl>" style="background-position: {tc}; height: {frameWidth}px" role="presentation"></div>',
+                '<tpl if="right"></div></tpl>',
+            '<tpl if="left"></div></tpl>',
+        '</tpl>',
+        '<tpl if="left"><div id="{fgid}ML" class="{frameCls}-ml {baseCls}-ml {baseCls}-{ui}-ml<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-ml</tpl>" style="background-position: {ml}; padding-left: {frameWidth}px" role="presentation"></tpl>',
+            '<tpl if="right"><div id="{fgid}MR" class="{frameCls}-mr {baseCls}-mr {baseCls}-{ui}-mr<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-mr</tpl>" style="background-position: {mr}; padding-right: {frameWidth}px" role="presentation"></tpl>',
+                '<div id="{fgid}MC" class="{frameCls}-mc {baseCls}-mc {baseCls}-{ui}-mc<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-mc</tpl>" role="presentation">',
+                    '{%this.applyRenderTpl(out, values)%}',
+                '</div>',
+            '<tpl if="right"></div></tpl>',
+        '<tpl if="left"></div></tpl>',
+        '<tpl if="bottom">',
+            '<tpl if="left"><div id="{fgid}BL" class="{frameCls}-bl {baseCls}-bl {baseCls}-{ui}-bl<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-bl</tpl>" style="background-position: {bl}; padding-left: {frameWidth}px" role="presentation"></tpl>',
+                '<tpl if="right"><div id="{fgid}BR" class="{frameCls}-br {baseCls}-br {baseCls}-{ui}-br<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-br</tpl>" style="background-position: {br}; padding-right: {frameWidth}px" role="presentation"></tpl>',
+                    '<div id="{fgid}BC" class="{frameCls}-bc {baseCls}-bc {baseCls}-{ui}-bc<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-bc</tpl>" style="background-position: {bc}; height: {frameWidth}px" role="presentation"></div>',
+                '<tpl if="right"></div></tpl>',
+            '<tpl if="left"></div></tpl>',
+        '</tpl>',
+        '{%this.renderDockedItems(out,values,1);%}'
+    ],
+
+    frameTableTpl: [
+        '{%this.renderDockedItems(out,values,0);%}',
+        '<table><tbody>',
+            '<tpl if="top">',
+                '<tr>',
+                    '<tpl if="left"><td id="{fgid}TL" class="{frameCls}-tl {baseCls}-tl {baseCls}-{ui}-tl<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-tl</tpl>" style="background-position: {tl}; padding-left:{frameWidth}px" role="presentation"></td></tpl>',
+                    '<td id="{fgid}TC" class="{frameCls}-tc {baseCls}-tc {baseCls}-{ui}-tc<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-tc</tpl>" style="background-position: {tc}; height: {frameWidth}px" role="presentation"></td>',
+                    '<tpl if="right"><td id="{fgid}TR" class="{frameCls}-tr {baseCls}-tr {baseCls}-{ui}-tr<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-tr</tpl>" style="background-position: {tr}; padding-left: {frameWidth}px" role="presentation"></td></tpl>',
+                '</tr>',
+            '</tpl>',
+            '<tr>',
+                '<tpl if="left"><td id="{fgid}ML" class="{frameCls}-ml {baseCls}-ml {baseCls}-{ui}-ml<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-ml</tpl>" style="background-position: {ml}; padding-left: {frameWidth}px" role="presentation"></td></tpl>',
+                '<td id="{fgid}MC" class="{frameCls}-mc {baseCls}-mc {baseCls}-{ui}-mc<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-mc</tpl>" style="background-position: 0 0;" role="presentation">',
+                    '{%this.applyRenderTpl(out, values)%}',
+                '</td>',
+                '<tpl if="right"><td id="{fgid}MR" class="{frameCls}-mr {baseCls}-mr {baseCls}-{ui}-mr<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-mr</tpl>" style="background-position: {mr}; padding-left: {frameWidth}px" role="presentation"></td></tpl>',
+            '</tr>',
+            '<tpl if="bottom">',
+                '<tr>',
+                    '<tpl if="left"><td id="{fgid}BL" class="{frameCls}-bl {baseCls}-bl {baseCls}-{ui}-bl<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-bl</tpl>" style="background-position: {bl}; padding-left: {frameWidth}px" role="presentation"></td></tpl>',
+                    '<td id="{fgid}BC" class="{frameCls}-bc {baseCls}-bc {baseCls}-{ui}-bc<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-bc</tpl>" style="background-position: {bc}; height: {frameWidth}px" role="presentation"></td>',
+                    '<tpl if="right"><td id="{fgid}BR" class="{frameCls}-br {baseCls}-br {baseCls}-{ui}-br<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-br</tpl>" style="background-position: {br}; padding-left: {frameWidth}px" role="presentation"></td></tpl>',
+                '</tr>',
+            '</tpl>',
+        '</tbody></table>',
+        '{%this.renderDockedItems(out,values,1);%}'
+    ],
+
+    
+    afterRender : function() {
+        var me = this,
+            data = {},
+            protoEl = me.protoEl,
+            target = me.getTargetEl(),
+            item;
+
+        me.finishRenderChildren();
+
+        if (me.styleHtmlContent) {
+            target.addCls(me.styleHtmlCls);
+        }
+        
+        protoEl.writeTo(data);
+        
+        
+        
+        
+        item = data.removed;
+        if (item) {
+            target.removeCls(item);
+        }
+        
+        item = data.cls;
+        if (item.length) {
+            target.addCls(item);
+        }
+        
+        item = data.style;
+        if (data.style) {
+            target.setStyle(item);
+        }
+        
+        me.protoEl = null;
+
+        
+        if (!me.ownerCt) {
+            me.updateLayout();
+        }
+    },
+
+    afterFirstLayout : function(width, height) {
+        var me = this,
+            hasX = Ext.isDefined(me.x),
+            hasY = Ext.isDefined(me.y),
+            pos, xy;
+
+        
+        
+        if (me.floating && (!hasX || !hasY)) {
+            if (me.floatParent) {
+                pos = me.floatParent.getTargetEl().getViewRegion();
+                xy = me.el.getAlignToXY(me.floatParent.getTargetEl(), 'c-c');
+                pos.left = xy[0] - pos.left;
+                pos.top =  xy[1] - pos.top;
+            } else {
+                xy = me.el.getAlignToXY(me.container, 'c-c');
+                pos = me.container.translatePoints(xy[0], xy[1]);
+            }
+            me.x = hasX ? me.x : pos.left;
+            me.y = hasY ? me.y : pos.top;
+            hasX = hasY = true;
+        }
+
+        if (hasX || hasY) {
+            me.setPosition(me.x, me.y);
+        }
+        me.onBoxReady(width, height);
+        if (me.hasListeners.boxready) {
+            me.fireEvent('boxready', me, width, height);
+        }
+    },
+
+    onBoxReady: Ext.emptyFn,
+
+    
+    applyRenderSelectors: function() {
+        var me = this,
+            selectors = me.renderSelectors,
+            el = me.el,
+            dom = el.dom,
+            selector;
+
+        me.applyChildEls(el);
+
+        
+        
+        
+        if (selectors) {
+            for (selector in selectors) {
+                if (selectors.hasOwnProperty(selector) && selectors[selector]) {
+                    me[selector] = Ext.get(Ext.DomQuery.selectNode(selectors[selector], dom));
+                }
+            }
+        }
+    },
+
+    beforeRender: function () {
+        var me = this,
+            target = me.getTargetEl(),
+            layout = me.getComponentLayout();
+
+        
+        me.frame = me.frame || me.alwaysFramed;
+
+        if (!layout.initialized) {
+            layout.initLayout();
+        }
+
+        
+        
+        if (target) {
+            target.setStyle(me.getOverflowStyle());
+            me.overflowStyleSet = true;
+        }
+
+        me.setUI(me.ui);
+
+        if (me.disabled) {
+            
+            me.disable(true);
+        }
+    },
+
+    
+    doApplyRenderTpl: function(out, values) {
+        
+        
+
+        var me = values.$comp,
+            tpl;
+
+        
+        if (!me.rendered) {
+            tpl = me.initRenderTpl();
+            tpl.applyOut(values.renderData, out);
+        }
+    },
+
+    
+    doAutoRender: function() {
+        var me = this;
+        if (!me.rendered) {
+            if (me.floating) {
+                me.render(document.body);
+            } else {
+                me.render(Ext.isBoolean(me.autoRender) ? Ext.getBody() : me.autoRender);
+            }
+        }
+    },
+
+    doRenderContent: function (out, renderData) {
+        
+        
+
+        var me = renderData.$comp;
+
+        if (me.html) {
+            Ext.DomHelper.generateMarkup(me.html, out);
+            delete me.html;
+        }
+
+        if (me.tpl) {
+            
+            if (!me.tpl.isTemplate) {
+                me.tpl = new Ext.XTemplate(me.tpl);
+            }
+
+            if (me.data) {
+                
+                me.tpl.applyOut(me.data, out);
+                delete me.data;
+            }
+        }
+    },
+
+    doRenderFramingDockedItems: function (out, renderData, after) {
+        
+        
+
+        var me = renderData.$comp;
+
+        
+        
+        if (!me.rendered && me.doRenderDockedItems) {
+            
+            
+            renderData.renderData.$skipDockedItems = true;
+
+            
+            
+            me.doRenderDockedItems.call(this, out, renderData, after);
+        }
+    },
+
+    
+    finishRender: function(containerIdx) {
+        var me = this,
+            tpl, data, contentEl, el, pre, hide;
+
+        
+        
+        
+        
+        
+        
+        
+
+        if (!me.el || me.$pid) {
+            if (me.container) {
+                el = me.container.getById(me.id, true);
+            } else {
+                el = Ext.getDom(me.id);
+            }
+
+            if (!me.el) {
+                
+                me.wrapPrimaryEl(el);
+            } else {
+                
+                
+                delete me.$pid;
+
+                if (!me.el.dom) {
+                    
+                    me.wrapPrimaryEl(me.el);
+                }
+                el.parentNode.insertBefore(me.el.dom, el);
+                Ext.removeNode(el); 
+                
+            }
+        } else if (!me.rendering) {
+            
+            
+            
+            tpl = me.initRenderTpl();
+            if (tpl) {
+                data = me.initRenderData();
+                tpl.insertFirst(me.getTargetEl(), data);
+            }
+        }
+        
+
+        if (!me.container) {
+            
+            me.container = Ext.get(me.el.dom.parentNode);
+        }
+
+        if (me.ctCls) {
+            me.container.addCls(me.ctCls);
+        }
+
+        
+        me.onRender(me.container, containerIdx);
+
+        
+        if (!me.overflowStyleSet) {
+            me.getTargetEl().setStyle(me.getOverflowStyle());
+        }
+
+        
+        
+        me.el.setVisibilityMode(Ext.Element[me.hideMode.toUpperCase()]);
+
+        if (me.overCls) {
+            me.el.hover(me.addOverCls, me.removeOverCls, me);
+        }
+
+        if (me.hasListeners.render) {
+            me.fireEvent('render', me);
+        }
+
+        if (me.contentEl) {
+            pre = Ext.baseCSSPrefix;
+            hide = pre + 'hide-';
+            contentEl = Ext.get(me.contentEl);
+            contentEl.removeCls([pre+'hidden', hide+'display', hide+'offsets', hide+'nosize']);
+            me.getTargetEl().appendChild(contentEl.dom);
+        }
+
+        me.afterRender(); 
+        if (me.hasListeners.afterrender) {
+            me.fireEvent('afterrender', me);
+        }
+        me.initEvents();
+
+        if (me.hidden) {
+            
+            
+            
+            me.el.hide();
+        }
+    },
+
+    finishRenderChildren: function () {
+        var layout = this.getComponentLayout();
+
+        layout.finishRender();
+    },
+
+    getElConfig : function() {
+        var me = this,
+            autoEl = me.autoEl,
+            frameInfo = me.getFrameInfo(),
+            config = {
+                tag: 'div',
+                tpl: frameInfo ? me.initFramingTpl(frameInfo.table) : me.initRenderTpl()
+            },
+            i, frameElNames, len, suffix, frameGenId;
+
+        me.initStyles(me.protoEl);
+        me.protoEl.writeTo(config);
+        me.protoEl.flush();
+
+        if (Ext.isString(autoEl)) {
+            config.tag = autoEl;
+        } else {
+            Ext.apply(config, autoEl); 
+        }
+
+        
+        config.id = me.id;
+
+        if (config.tpl) {
+            
+            if (frameInfo) {
+                frameElNames = me.frameElNames;
+                len = frameElNames.length;
+                frameGenId = me.id + '-frame1';
+
+                me.frameGenId = 1;
+                config.tplData = Ext.apply({}, {
+                    $comp:      me,
+                    fgid:       frameGenId,
+                    ui:         me.ui,
+                    uiCls:      me.uiCls,
+                    frameCls:   me.frameCls,
+                    baseCls:    me.baseCls,
+                    frameWidth: frameInfo.maxWidth,
+                    top:        !!frameInfo.top,
+                    left:       !!frameInfo.left,
+                    right:      !!frameInfo.right,
+                    bottom:     !!frameInfo.bottom,
+                    renderData: me.initRenderData()
+                }, me.getFramePositions(frameInfo));
+
+                
+                for (i = 0; i < len; i++) {
+                    suffix = frameElNames[i];
+                    me.addChildEls({ name: 'frame' + suffix, id: frameGenId + suffix });
+                }
+
+                
+                me.addChildEls({
+                    name: 'frameBody',
+                    id: frameGenId + 'MC'
+                });
+            } else {
+                config.tplData = me.initRenderData();
+            }
+        }
+
+        return config;
+    },
+
+    
+    
+    initFramingTpl: function(table) {
+        var tpl = table ? this.getTpl('frameTableTpl') : this.getTpl('frameTpl');
+
+        if (tpl && !tpl.applyRenderTpl) {
+            this.setupFramingTpl(tpl);
+        }
+
+        return tpl;
+    },
+
+    
+    setupFramingTpl: function(frameTpl) {
+        frameTpl.applyRenderTpl = this.doApplyRenderTpl;
+        frameTpl.renderDockedItems = this.doRenderFramingDockedItems;
+    },
+
+    
+    getInsertPosition: function(position) {
+        
+        if (position !== undefined) {
+            if (Ext.isNumber(position)) {
+                position = this.container.dom.childNodes[position];
+            }
+            else {
+                position = Ext.getDom(position);
+            }
+        }
+
+        return position;
+    },
+
+    getRenderTree: function() {
+        var me = this;
+
+        if (!me.hasListeners.beforerender || me.fireEvent('beforerender', me) !== false) {
+            me.beforeRender();
+
+            
+            
+            me.rendering = true;
+
+            if (me.el) {
+                
+                
+                
+                return {
+                    tag: 'div',
+                    id: (me.$pid = Ext.id())
+                };
+            }
+
+            return me.getElConfig();
+        }
+
+        return null;
+    },
+
+    initContainer: function(container) {
+        var me = this;
+
+        
+        
+        
+        if (!container && me.el) {
+            container = me.el.dom.parentNode;
+            me.allowDomMove = false;
+        }
+        me.container = container.dom ? container : Ext.get(container);
+
+        return me.container;
+    },
+
+    
+    initRenderData: function() {
+        var me = this;
+
+        return Ext.apply({
+            $comp: me,
+            id: me.id,
+            ui: me.ui,
+            uiCls: me.uiCls,
+            baseCls: me.baseCls,
+            componentCls: me.componentCls,
+            frame: me.frame
+        }, me.renderData);
+    },
+
+    
+    initRenderTpl: function() {
+        var tpl = this.getTpl('renderTpl');
+
+        if (tpl && !tpl.renderContent) {
+            this.setupRenderTpl(tpl);
+        }
+
+        return tpl;
+    },
+
+    
+    onRender: function(parentNode, containerIdx) {
+        var me = this,
+            x = me.x,
+            y = me.y,
+            lastBox, width, height,
+            el = me.el,
+            body = Ext.getBody().dom;
+
+        
+        if (Ext.scopeResetCSS && !me.ownerCt) {
+            
+            if (el.dom === body) {
+                el.parent().addCls(Ext.resetCls);
+            }
+            
+            else {
+                
+                if (me.floating && me.el.dom.parentNode === body) {
+                    Ext.resetElement.appendChild(me.el);
+                }
+                
+                else {
+                    
+                    me.resetEl = el.wrap(Ext.resetElementSpec, false, Ext.supports.CSS3LinearGradient ? undefined : '*');
+                }
+            }
+        }
+
+        me.applyRenderSelectors();
+
+        
+        
+        delete me.rendering;
+
+        me.rendered = true;
+
+        
+        lastBox = null;
+
+        if (x !== undefined) {
+            lastBox = lastBox || {};
+            lastBox.x = x;
+        }
+        if (y !== undefined) {
+            lastBox = lastBox || {};
+            lastBox.y = y;
+        }
+        
+        
+        
+        if (!me.getFrameInfo() && Ext.isBorderBox) {
+            width = me.width;
+            height = me.height;
+
+            if (typeof width == 'number') {
+                lastBox = lastBox || {};
+                lastBox.width = width;
+            }
+            if (typeof height == 'number') {
+                lastBox = lastBox || {};
+                lastBox.height = height;
+            }
+        }
+
+        me.lastBox = me.el.lastBox = lastBox;
+    },
+
+    
+    render: function(container, position) {
+        var me = this,
+            el = me.el && (me.el = Ext.get(me.el)), 
+            vetoed,
+            tree,
+            nextSibling;
+
+        Ext.suspendLayouts();
+
+        container = me.initContainer(container);
+
+        nextSibling = me.getInsertPosition(position);
+
+        if (!el) {
+            tree = me.getRenderTree();
+            if (me.ownerLayout && me.ownerLayout.transformItemRenderTree) {
+                tree = me.ownerLayout.transformItemRenderTree(tree);
+            }
+
+            
+            if (tree) {
+                if (nextSibling) {
+                    el = Ext.DomHelper.insertBefore(nextSibling, tree);
+                } else {
+                    el = Ext.DomHelper.append(container, tree);
+                }
+
+                me.wrapPrimaryEl(el);
+            }
+        } else {
+            if (!me.hasListeners.beforerender || me.fireEvent('beforerender', me) !== false) {
+                
+                me.initStyles(el);
+                if (me.allowDomMove !== false) {
+                    
+                    if (nextSibling) {
+                        container.dom.insertBefore(el.dom, nextSibling);
+                    } else {
+                        container.dom.appendChild(el.dom);
+                    }
+                }
+            } else {
+                vetoed = true;
+            }
+        }
+
+        if (el && !vetoed) {
+            me.finishRender(position);
+        }
+
+        Ext.resumeLayouts(!container.isDetachedBody);
+    },
+
+    
+    ensureAttachedToBody: function (runLayout) {
+        var comp = this,
+            body;
+
+        while (comp.ownerCt) {
+            comp = comp.ownerCt;
+        }
+
+        if (comp.container.isDetachedBody) {
+            comp.container = body = Ext.resetElement;
+            body.appendChild(comp.el.dom);
+            if (runLayout) {
+                comp.updateLayout();
+            }
+            if (typeof comp.x == 'number' || typeof comp.y == 'number') {
+                comp.setPosition(comp.x, comp.y);
+            }
+        }
+    },
+
+    setupRenderTpl: function (renderTpl) {
+        renderTpl.renderBody = renderTpl.renderContent = this.doRenderContent;
+    },
+
+    wrapPrimaryEl: function (dom) {
+        this.el = Ext.get(dom, true);
+    },
+
+    
+    initFrame : function() {
+        if (Ext.supports.CSS3BorderRadius || !this.frame) {
+            return;
+        }
+
+        var me = this,
+            frameInfo = me.getFrameInfo(),
+            frameWidth, frameTpl, frameGenId,
+            i,
+            frameElNames = me.frameElNames,
+            len = frameElNames.length,
+            suffix;
+
+        if (frameInfo) {
+            frameWidth = frameInfo.maxWidth;
+            frameTpl = me.getFrameTpl(frameInfo.table);
+
+            
+            
+            me.frameGenId = frameGenId = (me.frameGenId || 0) + 1;
+            frameGenId = me.id + '-frame' + frameGenId;
+
+            
+            frameTpl.insertFirst(me.el, Ext.apply({
+                $comp:      me,
+                fgid:       frameGenId,
+                ui:         me.ui,
+                uiCls:      me.uiCls,
+                frameCls:   me.frameCls,
+                baseCls:    me.baseCls,
+                frameWidth: frameWidth,
+                top:        !!frameInfo.top,
+                left:       !!frameInfo.left,
+                right:      !!frameInfo.right,
+                bottom:     !!frameInfo.bottom
+            }, me.getFramePositions(frameInfo)));
+
+            
+            me.frameBody = me.el.down('.' + me.frameCls + '-mc');
+
+            
+            me.removeChildEls(function (c) {
+                return c.id && me.frameIdRegex.test(c.id);
+            });
+
+            
+            for (i = 0; i < len; i++) {
+                suffix = frameElNames[i];
+                me['frame' + suffix] = me.el.getById(frameGenId + suffix);
+            }
+        }
+    },
+
+    updateFrame: function() {
+        if (Ext.supports.CSS3BorderRadius || !this.frame) {
+            return;
+        }
+
+        var me = this,
+            wasTable = this.frameSize && this.frameSize.table,
+            oldFrameTL = this.frameTL,
+            oldFrameBL = this.frameBL,
+            oldFrameML = this.frameML,
+            oldFrameMC = this.frameMC,
+            newMCClassName;
+
+        this.initFrame();
+
+        if (oldFrameMC) {
+            if (me.frame) {
+
+                
+                newMCClassName = this.frameMC.dom.className;
+
+                
+                
+                oldFrameMC.insertAfter(this.frameMC);
+                this.frameMC.remove();
+
+                
+                this.frameBody = this.frameMC = oldFrameMC;
+
+                
+                oldFrameMC.dom.className = newMCClassName;
+
+                
+                if (wasTable) {
+                    me.el.query('> table')[1].remove();
+                }
+                else {
+                    if (oldFrameTL) {
+                        oldFrameTL.remove();
+                    }
+                    if (oldFrameBL) {
+                        oldFrameBL.remove();
+                    }
+                    if (oldFrameML) {
+                        oldFrameML.remove();
+                    }
+                }
+            }
+        }
+        else if (me.frame) {
+            this.applyRenderSelectors();
+        }
+    },
+
+    
+    getFrameInfo: function() {
+        
+        if (Ext.supports.CSS3BorderRadius || !this.frame) {
+            return false;
+        }
+
+        var me = this,
+            frameInfoCache = me.frameInfoCache,
+            el = me.el || me.protoEl,
+            cls = el.dom ? el.dom.className : el.classList.join(' '),
+            frameInfo = frameInfoCache[cls],
+            styleEl, left, top, info;
+
+        if (frameInfo == null) {
+            
+            styleEl = Ext.fly(me.getStyleProxy(cls), 'frame-style-el');
+            left = styleEl.getStyle('background-position-x');
+            top = styleEl.getStyle('background-position-y');
+
+            
+            
+            if (!left && !top) {
+                info = styleEl.getStyle('background-position').split(' ');
+                left = info[0];
+                top = info[1];
+            }
+
+            frameInfo = me.calculateFrame(left, top);
+
+            if (frameInfo) {
+                
+                el.setStyle('background-image', 'none');
+            }
+
+
+            frameInfoCache[cls] = frameInfo;
+        }
+
+        me.frame = !!frameInfo;
+        me.frameSize = frameInfo;
+
+        return frameInfo;
+    },
+    
+    calculateFrame: function(left, top){
+        
+        
+        
+        if (!(parseInt(left, 10) >= 1000000 && parseInt(top, 10) >= 1000000)) {
+            return false;
+        }
+        var max = Math.max,
+            tl = parseInt(left.substr(3, 2), 10),
+            tr = parseInt(left.substr(5, 2), 10),
+            br = parseInt(top.substr(3, 2), 10),
+            bl = parseInt(top.substr(5, 2), 10),
+            frameInfo = {
+                
+                table: left.substr(0, 3) == '110',
+
+                
+                vertical: top.substr(0, 3) == '110',
+
+                
+                top:    max(tl, tr),
+                right:  max(tr, br),
+                bottom: max(bl, br),
+                left:   max(tl, bl)
+            };
+
+        frameInfo.maxWidth = max(frameInfo.top, frameInfo.right, frameInfo.bottom, frameInfo.left);
+        frameInfo.width = frameInfo.left + frameInfo.right;
+        frameInfo.height = frameInfo.top + frameInfo.bottom;
+        return frameInfo;
+    },
+
+    
+    getStyleProxy: function(cls) {
+        var result = this.styleProxyEl || (Ext.AbstractComponent.prototype.styleProxyEl = Ext.resetElement.createChild({
+                style: {
+                    position: 'absolute',
+                    top: '-10000px'
+                }
+            }, null, true));
+
+        result.className = cls;
+        return result;
+    },
+
+    getFramePositions: function(frameInfo) {
+        var me = this,
+            frameWidth = frameInfo.maxWidth,
+            dock = me.dock,
+            positions, tc, bc, ml, mr;
+
+        if (frameInfo.vertical) {
+            tc = '0 -' + (frameWidth * 0) + 'px';
+            bc = '0 -' + (frameWidth * 1) + 'px';
+
+            if (dock && dock == "right") {
+                tc = 'right -' + (frameWidth * 0) + 'px';
+                bc = 'right -' + (frameWidth * 1) + 'px';
+            }
+
+            positions = {
+                tl: '0 -' + (frameWidth * 0) + 'px',
+                tr: '0 -' + (frameWidth * 1) + 'px',
+                bl: '0 -' + (frameWidth * 2) + 'px',
+                br: '0 -' + (frameWidth * 3) + 'px',
+
+                ml: '-' + (frameWidth * 1) + 'px 0',
+                mr: 'right 0',
+
+                tc: tc,
+                bc: bc
+            };
+        } else {
+            ml = '-' + (frameWidth * 0) + 'px 0';
+            mr = 'right 0';
+
+            if (dock && dock == "bottom") {
+                ml = 'left bottom';
+                mr = 'right bottom';
+            }
+
+            positions = {
+                tl: '0 -' + (frameWidth * 2) + 'px',
+                tr: 'right -' + (frameWidth * 3) + 'px',
+                bl: '0 -' + (frameWidth * 4) + 'px',
+                br: 'right -' + (frameWidth * 5) + 'px',
+
+                ml: ml,
+                mr: mr,
+
+                tc: '0 -' + (frameWidth * 0) + 'px',
+                bc: '0 -' + (frameWidth * 1) + 'px'
+            };
+        }
+
+        return positions;
+    },
+
+    
+    getFrameTpl : function(table) {
+        return this.getTpl(table ? 'frameTableTpl' : 'frameTpl');
+    },
+
+    
+    frameInfoCache: {}
+});
+
+
+Ext.define('Ext.state.Provider', {
+    mixins: {
+        observable: 'Ext.util.Observable'
+    },
+    
+    
+    prefix: 'ext-',
+    
+    constructor : function(config){
+        config = config || {};
+        var me = this;
+        Ext.apply(me, config);
+        
+        me.addEvents("statechange");
+        me.state = {};
+        me.mixins.observable.constructor.call(me);
+    },
+    
+    
+    get : function(name, defaultValue){
+        return typeof this.state[name] == "undefined" ?
+            defaultValue : this.state[name];
+    },
+
+    
+    clear : function(name){
+        var me = this;
+        delete me.state[name];
+        me.fireEvent("statechange", me, name, null);
+    },
+
+    
+    set : function(name, value){
+        var me = this;
+        me.state[name] = value;
+        me.fireEvent("statechange", me, name, value);
+    },
+
+    
+    decodeValue : function(value){
+
+        
+        
+        
+        
+        
+        
+        
+
+        var me = this,
+            re = /^(a|n|d|b|s|o|e)\:(.*)$/,
+            matches = re.exec(unescape(value)),
+            all,
+            type,
+            keyValue,
+            values,
+            vLen,
+            v;
+            
+        if(!matches || !matches[1]){
+            return; 
+        }
+        
+        type = matches[1];
+        value = matches[2];
+        switch (type) {
+            case 'e':
+                return null;
+            case 'n':
+                return parseFloat(value);
+            case 'd':
+                return new Date(Date.parse(value));
+            case 'b':
+                return (value == '1');
+            case 'a':
+                all = [];
+                if(value != ''){
+                    values = value.split('^');
+                    vLen   = values.length;
+
+                    for (v = 0; v < vLen; v++) {
+                        value = values[v];
+                        all.push(me.decodeValue(value));
+                    }
+                }
+                return all;
+           case 'o':
+                all = {};
+                if(value != ''){
+                    values = value.split('^');
+                    vLen   = values.length;
+
+                    for (v = 0; v < vLen; v++) {
+                        value = values[v];
+                        keyValue         = value.split('=');
+                        all[keyValue[0]] = me.decodeValue(keyValue[1]);
+                    }
+                }
+                return all;
+           default:
+                return value;
+        }
+    },
+
+    
+    encodeValue : function(value){
+        var flat = '',
+            i = 0,
+            enc,
+            len,
+            key;
+            
+        if (value == null) {
+            return 'e:1';    
+        } else if(typeof value == 'number') {
+            enc = 'n:' + value;
+        } else if(typeof value == 'boolean') {
+            enc = 'b:' + (value ? '1' : '0');
+        } else if(Ext.isDate(value)) {
+            enc = 'd:' + value.toGMTString();
+        } else if(Ext.isArray(value)) {
+            for (len = value.length; i < len; i++) {
+                flat += this.encodeValue(value[i]);
+                if (i != len - 1) {
+                    flat += '^';
+                }
+            }
+            enc = 'a:' + flat;
+        } else if (typeof value == 'object') {
+            for (key in value) {
+                if (typeof value[key] != 'function' && value[key] !== undefined) {
+                    flat += key + '=' + this.encodeValue(value[key]) + '^';
+                }
+            }
+            enc = 'o:' + flat.substring(0, flat.length-1);
+        } else {
+            enc = 's:' + value;
+        }
+        return escape(enc);
+    }
+});
+
+
+Ext.define('Ext.state.Manager', {
+    singleton: true,
+    requires: ['Ext.state.Provider'],
+    constructor: function() {
+        this.provider = new Ext.state.Provider();
+    },
+    
+    
+    
+    setProvider : function(stateProvider){
+        this.provider = stateProvider;
+    },
+
+    
+    get : function(key, defaultValue){
+        return this.provider.get(key, defaultValue);
+    },
+
+    
+     set : function(key, value){
+        this.provider.set(key, value);
+    },
+
+    
+    clear : function(key){
+        this.provider.clear(key);
+    },
+
+    
+    getProvider : function(){
+        return this.provider;
+    }
+});
+
+
+Ext.define('Ext.state.Stateful', {
+
+    
+
+    mixins: {
+        observable: 'Ext.util.Observable'
+    },
+
+    requires: ['Ext.state.Manager'],
+
+    
+
+    
+    stateful: false,
+
+    
+
+    
+
+    
+    saveDelay: 100,
+
+    constructor: function(config) {
+        var me = this;
+
+        config = config || {};
+        if (config.stateful !== undefined) {
+            me.stateful = config.stateful;
+        }
+        if (config.saveDelay !== undefined) {
+            me.saveDelay = config.saveDelay;
+        }
+        me.stateId = me.stateId || config.stateId;
+
+        if (!me.stateEvents) {
+            me.stateEvents = [];
+        }
+        if (config.stateEvents) {
+            me.stateEvents.concat(config.stateEvents);
+        }
+        this.addEvents(
+            
+            'beforestaterestore',
+
+            
+            'staterestore',
+
+            
+            'beforestatesave',
+
+            
+            'statesave'
+        );
+        me.mixins.observable.constructor.call(me);
+
+        if (me.stateful !== false) {
+            me.addStateEvents(me.stateEvents);
+            me.initState();
+        }
+    },
+
+    
+    addStateEvents: function (events) {
+        var me = this,
+            i, event, stateEventsByName;
+
+        if (me.stateful && me.getStateId()) {
+            if (typeof events == 'string') {
+                events = Array.prototype.slice.call(arguments, 0);
+            }
+
+            stateEventsByName = me.stateEventsByName || (me.stateEventsByName = {});
+
+            for (i = events.length; i--; ) {
+                event = events[i];
+
+                if (!stateEventsByName[event]) {
+                    stateEventsByName[event] = 1;
+                    me.on(event, me.onStateChange, me);
+                }
+            }
+        }
+    },
+
+    
+    onStateChange: function(){
+        var me = this,
+            delay = me.saveDelay,
+            statics, runner;
+
+        if (!me.stateful) {
+            return;
+        }
+
+        if (delay) {
+            if (!me.stateTask) {
+                statics = Ext.state.Stateful;
+                runner = statics.runner || (statics.runner = new Ext.util.TaskRunner());
+
+                me.stateTask = runner.newTask({
+                    run: me.saveState,
+                    scope: me,
+                    interval: delay,
+                    repeat: 1
+                });
+            }
+
+            me.stateTask.start();
+        } else {
+            me.saveState();
+        }
+    },
+
+    
+    saveState: function() {
+        var me = this,
+            id = me.stateful && me.getStateId(),
+            hasListeners = me.hasListeners,
+            state;
+
+        if (id) {
+            state = me.getState() || {};    
+            if (!hasListeners.beforestatesave || me.fireEvent('beforestatesave', me, state) !== false) {
+                Ext.state.Manager.set(id, state);
+                if (hasListeners.statesave) {
+                    me.fireEvent('statesave', me, state);
+                }
+            }
+        }
+    },
+
+    
+    getState: function(){
+        return null;
+    },
+
+    
+    applyState: function(state) {
+        if (state) {
+            Ext.apply(this, state);
+        }
+    },
+
+    
+    getStateId: function() {
+        var me = this;
+        return me.stateId || (me.autoGenId ? null : me.id);
+    },
+
+    
+    initState: function(){
+        var me = this,
+            id = me.stateful && me.getStateId(),
+            hasListeners = me.hasListeners,
+            state;
+
+        if (id) {
+            state = Ext.state.Manager.get(id);
+            if (state) {
+                state = Ext.apply({}, state);
+                if (!hasListeners.beforestaterestore || me.fireEvent('beforestaterestore', me, state) !== false) {
+                    me.applyState(state);
+                    if (hasListeners.staterestore) {
+                        me.fireEvent('staterestore', me, state);
+                    }
+                }
+            }
+        }
+    },
+
+    
+    savePropToState: function (propName, state, stateName) {
+        var me = this,
+            value = me[propName],
+            config = me.initialConfig;
+
+        if (me.hasOwnProperty(propName)) {
+            if (!config || config[propName] !== value) {
+                if (state) {
+                    state[stateName || propName] = value;
+                }
+                return true;
+            }
+        }
+        return false;
+    },
+
+    
+    savePropsToState: function (propNames, state) {
+        var me = this,
+            i, n;
+
+        if (typeof propNames == 'string') {
+            me.savePropToState(propNames, state);
+        } else {
+            for (i = 0, n = propNames.length; i < n; ++i) {
+                me.savePropToState(propNames[i], state);
+            }
+        }
+
+        return state;
+    },
+
+    
+    destroy: function(){
+        var me = this,
+            task = me.stateTask;
+
+        if (task) {
+            task.destroy();
+            me.stateTask = null;
+        }
+
+        me.clearListeners();
+    }
+});
+
+
+Ext.define('Ext.AbstractComponent', {
+
+    
+    requires: [
+        'Ext.ComponentQuery',
+        'Ext.ComponentManager',
+        'Ext.util.ProtoElement'
+    ],
+
+    mixins: {
+        observable: 'Ext.util.Observable',
+        animate: 'Ext.util.Animate',
+        elementCt: 'Ext.util.ElementContainer',
+        renderable: 'Ext.util.Renderable',
+        state: 'Ext.state.Stateful'
+    },
+
+    
+    
+    uses: [
+        'Ext.PluginManager',
+        'Ext.Element',
+        'Ext.DomHelper',
+        'Ext.XTemplate',
+        'Ext.ComponentQuery',
+        'Ext.ComponentLoader',
+        'Ext.EventManager',
+        'Ext.layout.Context',
+        'Ext.layout.Layout',
+        'Ext.layout.component.Auto',
+        'Ext.LoadMask',
+        'Ext.ZIndexManager'
+    ],
+
+    statics: {
+        AUTO_ID: 1000,
+
+        pendingLayouts: null,
+
+        layoutSuspendCount: 0,
+
+        
+        cancelLayout: function(comp, isDestroying) {
+            var context = this.runningLayoutContext || this.pendingLayouts;
+
+            if (context) {
+                context.cancelComponent(comp, false, isDestroying);
+            }
+        },
+
+        
+        flushLayouts: function () {
+            var me = this,
+                context = me.pendingLayouts;
+
+            if (context && context.invalidQueue.length) {
+                me.pendingLayouts = null;
+                me.runningLayoutContext = context;
+
+                Ext.override(context, {
+                    runComplete: function () {
+                        
+                        
+                        
+                        me.runningLayoutContext = null;
+
+                        return this.callParent(); 
+                    }
+                });
+
+                context.run();
+            }
+        },
+
+        
+        resumeLayouts: function (flush) {
+            if (this.layoutSuspendCount && ! --this.layoutSuspendCount) {
+                if (flush) {
+                    this.flushLayouts();
+                }
+            }
+        },
+
+        
+        suspendLayouts: function () {
+            ++this.layoutSuspendCount;
+        },
+
+        
+        updateLayout: function (comp, defer) {
+            var me = this,
+                running = me.runningLayoutContext,
+                pending;
+
+            if (running) {
+                running.queueInvalidate(comp);
+            } else {
+                pending = me.pendingLayouts || (me.pendingLayouts = new Ext.layout.Context());
+                pending.queueInvalidate(comp);
+
+                if (!defer && !me.layoutSuspendCount && !comp.isLayoutSuspended()) {
+                    me.flushLayouts();
+                }
+            }
+        }
+    },
+
+    
+
+    
+    isComponent: true,
+
+    
+    getAutoId: function() {
+        this.autoGenId = true;
+        return ++Ext.AbstractComponent.AUTO_ID;
+    },
+
+    deferLayouts: false,
+
+    
+
+     
+    autoGenId: false,
+
+    
+
+    
+
+    
+
+    
+    renderTpl: '{%this.renderContent(out,values)%}',
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+    frameSize: { left: 0, top: 0, right: 0, bottom: 0, width: 0, height: 0 },
+
+    
+
+    
+
+    
+
+    
+
+    
+    tplWriteMode: 'overwrite',
+
+    
+    baseCls: Ext.baseCSSPrefix + 'component',
+
+    
+
+    
+
+    
+
+    
+    disabledCls: Ext.baseCSSPrefix + 'item-disabled',
+
+    
+    ui: 'default',
+
+    
+    uiCls: [],
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+    hidden: false,
+
+    
+    disabled: false,
+
+    
+
+    
+    draggable: false,
+
+    
+    floating: false,
+
+    
+    hideMode: 'display',
+
+    
+
+    
+
+    
+    styleHtmlContent: false,
+
+    
+    styleHtmlCls: Ext.baseCSSPrefix + 'html',
+
+    
+    
+    
+    
+
+    
+
+    
+
+    
+    autoShow: false,
+
+    
+    autoRender: false,
+
+    
+    allowDomMove: true,
+
+    
+
+    
+    rendered: false,
+
+    
+    componentLayoutCounter: 0,
+
+    
+    shrinkWrap: 2,
+
+    weight: 0,
+
+    
+    maskOnDisable: true,
+
+    
+    _isLayoutRoot: false,
+
+    
+    constructor : function(config) {
+        var me = this,
+            i, len, xhooks;
+
+        if (config) {
+            Ext.apply(me, config);
+
+            xhooks = me.xhooks;
+            if (xhooks) {
+                delete me.xhooks;
+                Ext.override(me, xhooks);
+            }
+        } else {
+            config = {};
+        }
+
+        me.initialConfig = config;
+
+        me.mixins.elementCt.constructor.call(me);
+
+        me.addEvents(
+            
+            'beforeactivate',
+            
+            'activate',
+            
+            'beforedeactivate',
+            
+            'deactivate',
+            
+            'added',
+            
+            'disable',
+            
+            'enable',
+            
+            'beforeshow',
+            
+            'show',
+            
+            'beforehide',
+            
+            'hide',
+            
+            'removed',
+            
+            'beforerender',
+            
+            'render',
+            
+            'afterrender',
+            
+            'boxready',
+            
+            'beforedestroy',
+            
+            'destroy',
+            
+            'resize',
+            
+             'move',
+            
+            'focus',
+            
+            'blur'
+        );
+
+        me.getId();
+
+        me.setupProtoEl();
+
+        
+        
+        if (me.cls) {
+            me.initialCls = me.cls;
+            me.protoEl.addCls(me.cls);
+        }
+        if (me.style) {
+            me.initialStyle = me.style;
+            me.protoEl.setStyle(me.style);
+        }
+
+        me.mons = [];
+        me.renderData = me.renderData || {};
+        me.renderSelectors = me.renderSelectors || {};
+
+        if (me.plugins) {
+            me.plugins = me.constructPlugins();
+        }
+
+        
+        if (!me.hasListeners) {
+            me.hasListeners = new me.HasListeners();
+        }
+
+        me.initComponent();
+
+        
+        Ext.ComponentManager.register(me);
+
+        
+        me.mixins.observable.constructor.call(me);
+        me.mixins.state.constructor.call(me, config);
+
+        
+        this.addStateEvents('resize');
+
+        
+        if (me.plugins) {
+            for (i = 0, len = me.plugins.length; i < len; i++) {
+                me.plugins[i] = me.initPlugin(me.plugins[i]);
+            }
+        }
+
+        me.loader = me.getLoader();
+
+        if (me.renderTo) {
+            me.render(me.renderTo);
+            
+            
+            
+        }
+
+        
+        
+        if (me.autoShow && !me.isContained) {
+            me.show();
+        }
+
+    },
+
+    initComponent: function () {
+        
+        
+        this.plugins = this.constructPlugins();
+
+        
+        
+        this.setSize(this.width, this.height);
+    },
+
+    
+    getState: function() {
+        var me = this,
+            state = null,
+            sizeModel = me.getSizeModel();
+
+        if (sizeModel.width.configured) {
+            state = me.addPropertyToState(state, 'width');
+        }
+        if (sizeModel.height.configured) {
+            state = me.addPropertyToState(state, 'height');
+        }
+
+        return state;
+    },
+
+    
+    addPropertyToState: function (state, propName, value) {
+        var me = this,
+            len = arguments.length;
+
+        
+        
+        if (len == 3 || me.hasOwnProperty(propName)) {
+            if (len < 3) {
+                value = me[propName];
+            }
+
+            
+            
+            if (value !== me.initialConfig[propName]) {
+                (state || (state = {}))[propName] = value;
+            }
+        }
+
+        return state;
+    },
+
+    show: Ext.emptyFn,
+
+    animate: function(animObj) {
+        var me = this,
+            hasToWidth,
+            hasToHeight,
+            toHeight,
+            toWidth,
+            to,
+            clearWidth,
+            clearHeight,
+            curWidth, w, curHeight, h, needsResize;
+
+        animObj = animObj || {};
+        to = animObj.to || {};
+
+        if (Ext.fx.Manager.hasFxBlock(me.id)) {
+            return me;
+        }
+
+        hasToWidth = Ext.isDefined(to.width);
+        if (hasToWidth) {
+            toWidth = Ext.Number.constrain(to.width, me.minWidth, me.maxWidth);
+        }
+
+        hasToHeight = Ext.isDefined(to.height);
+        if (hasToHeight) {
+            toHeight = Ext.Number.constrain(to.height, me.minHeight, me.maxHeight);
+        }
+
+        
+        if (!animObj.dynamic && (hasToWidth || hasToHeight)) {
+            curWidth = (animObj.from ? animObj.from.width : undefined) || me.getWidth();
+            w = curWidth;
+            curHeight = (animObj.from ? animObj.from.height : undefined) || me.getHeight();
+            h = curHeight;
+            needsResize = false;
+
+            if (hasToHeight && toHeight > curHeight) {
+                h = toHeight;
+                needsResize = true;
+            }
+            if (hasToWidth && toWidth > curWidth) {
+                w = toWidth;
+                needsResize = true;
+            }
+
+            
+            
+            
+            if (needsResize) {
+                clearWidth = !Ext.isNumber(me.width);
+                clearHeight = !Ext.isNumber(me.height);
+
+                me.setSize(w, h);
+                me.el.setSize(curWidth, curHeight);
+                if (clearWidth) {
+                    delete me.width;
+                }
+                if (clearHeight) {
+                    delete me.height;
+                }
+            }
+            if (hasToWidth) {
+                to.width = toWidth;
+            }
+
+            if (hasToHeight) {
+                to.height = toHeight;
+            }
+        }
+        return me.mixins.animate.animate.apply(me, arguments);
+    },
+
+    onHide: function() {
+        this.updateLayout({ isRoot: false });
+    },
+
+    onShow : function() {
+        this.updateLayout({ isRoot: false });
+    },
+
+    constructPlugin: function(plugin) {
+        
+        
+        if (plugin.ptype && typeof plugin.init != 'function') {
+            plugin.cmp = this;
+            plugin = Ext.PluginManager.create(plugin);
+        }
+        
+        else if (typeof plugin == 'string') {
+            plugin = Ext.PluginManager.create({
+                ptype: plugin,
+                cmp: this
+            });
+        }
+        return plugin;
+    },
+
+    
+    constructPlugins: function() {
+        var me = this,
+            plugins,
+            result = [],
+            i, len;
+
+        if (me.plugins) {
+            plugins = Ext.isArray(me.plugins) ? me.plugins : [ me.plugins ];
+            for (i = 0, len = plugins.length; i < len; i++) {
+                
+                result[i] = me.constructPlugin(plugins[i]);
+            }
+            return result;
+        }
+    },
+
+    
+    initPlugin : function(plugin) {
+        plugin.init(this);
+
+        return plugin;
+    },
+
+    
+    updateAria: Ext.emptyFn,
+
+    
+    registerFloatingItem: function(cmp) {
+        var me = this;
+        if (!me.floatingDescendants) {
+            me.floatingDescendants = new Ext.ZIndexManager(me);
+        }
+        me.floatingDescendants.register(cmp);
+    },
+
+    unregisterFloatingItem: function(cmp) {
+        var me = this;
+        if (me.floatingDescendants) {
+            me.floatingDescendants.unregister(cmp);
+        }
+    },
+
+    layoutSuspendCount: 0,
+
+    suspendLayouts: function () {
+        var me = this;
+        if (!me.rendered) {
+            return;
+        }
+        if (++me.layoutSuspendCount == 1) {
+            me.suspendLayout = true;
+        }
+    },
+
+    resumeLayouts: function (flushOptions) {
+        var me = this;
+        if (!me.rendered) {
+            return;
+        }
+        if (! --me.layoutSuspendCount) {
+            me.suspendLayout = false;
+            if (flushOptions && !me.isLayoutSuspended()) {
+                me.updateLayout(flushOptions);
+            }
+        }
+    },
+
+    setupProtoEl: function() {
+        var me = this,
+            cls = [ me.baseCls, me.getComponentLayout().targetCls ];
+
+        if (Ext.isDefined(me.cmpCls)) {
+            if (Ext.isDefined(Ext.global.console)) {
+                Ext.global.console.warn('Ext.Component: cmpCls has been deprecated. Please use componentCls.');
+            }
+            me.componentCls = me.cmpCls;
+            delete me.cmpCls;
+        }
+
+        if (me.componentCls) {
+            cls.push(me.componentCls);
+        } else {
+            me.componentCls = me.baseCls;
+        }
+
+        me.protoEl = new Ext.util.ProtoElement({
+            cls: cls.join(' ') 
+        });
+    },
+
+    
+    setUI: function(ui) {
+        var me = this,
+            oldUICls = Ext.Array.clone(me.uiCls),
+            newUICls = [],
+            classes = [],
+            cls,
+            i;
+
+        
+        for (i = 0; i < oldUICls.length; i++) {
+            cls = oldUICls[i];
+
+            classes = classes.concat(me.removeClsWithUI(cls, true));
+            newUICls.push(cls);
+        }
+
+        if (classes.length) {
+            me.removeCls(classes);
+        }
+
+        
+        me.removeUIFromElement();
+
+        
+        me.ui = ui;
+
+        
+        me.addUIToElement();
+
+        
+        classes = [];
+        for (i = 0; i < newUICls.length; i++) {
+            cls = newUICls[i];
+            classes = classes.concat(me.addClsWithUI(cls, true));
+        }
+
+        if (classes.length) {
+            me.addCls(classes);
+        }
+
+        
+        
+        
+        if (me.rendered) {
+            me.updateLayout();
+        }
+    },
+
+    
+    addClsWithUI: function(classes, skip) {
+        var me = this,
+            clsArray = [],
+            length,
+            i = 0,
+            cls;
+
+        if (typeof classes === "string") {
+            classes = (classes.indexOf(' ') < 0) ? [classes] : Ext.String.splitWords(classes);
+        }
+
+        length = classes.length;
+
+        me.uiCls = Ext.Array.clone(me.uiCls);
+
+        for (; i < length; i++) {
+            cls = classes[i];
+            if (cls && !me.hasUICls(cls)) {
+                me.uiCls.push(cls);
+                clsArray = clsArray.concat(me.addUIClsToElement(cls));
+            }
+        }
+
+        if (skip !== true) {
+            me.addCls(clsArray);
+        }
+
+        return clsArray;
+    },
+
+    
+    removeClsWithUI: function(classes, skip) {
+        var me = this,
+            clsArray = [],
+            i = 0,
+            length, cls;
+
+        if (typeof classes === "string") {
+            classes = (classes.indexOf(' ') < 0) ? [classes] : Ext.String.splitWords(classes);
+        }
+
+        length = classes.length;
+
+        for (i = 0; i < length; i++) {
+            cls = classes[i];
+            if (cls && me.hasUICls(cls)) {
+                me.uiCls = Ext.Array.remove(me.uiCls, cls);
+                clsArray = clsArray.concat(me.removeUIClsFromElement(cls));
+            }
+        }
+
+        if (skip !== true) {
+            me.removeCls(clsArray);
+        }
+
+        return clsArray;
+    },
+
+    
+    hasUICls: function(cls) {
+        var me = this,
+            uiCls = me.uiCls || [];
+
+        return Ext.Array.contains(uiCls, cls);
+    },
+
+    frameElementsArray: ['tl', 'tc', 'tr', 'ml', 'mc', 'mr', 'bl', 'bc', 'br'],
+
+    
+    addUIClsToElement: function(cls) {
+        var me = this,
+            baseClsUi = me.baseCls + '-' + me.ui + '-' + cls,
+            result = [Ext.baseCSSPrefix + cls, me.baseCls + '-' + cls, baseClsUi],
+            frameElementCls = me.frameElementCls,
+            frameElementsArray, frameElementsLength, i, el, frameElement, c;
+
+        if (me.frame && !Ext.supports.CSS3BorderRadius) {
+            
+            frameElementsArray = me.frameElementsArray;
+            frameElementsLength = frameElementsArray.length;
+            i = 0;
+
+            
+            for (; i < frameElementsLength; i++) {
+                frameElement = frameElementsArray[i];
+                el = me['frame' + frameElement.toUpperCase()];
+                c = baseClsUi + '-' + frameElement;
+                if (el && el.dom) {
+                    el.addCls(c);
+                } else if (Ext.Array.indexOf(frameElementCls[frameElement], c) == -1) {
+                    frameElementCls[frameElement].push(c);
+                }
+            }
+        }
+
+        me.frameElementCls = frameElementCls;
+
+        return result;
+    },
+
+    
+    removeUIClsFromElement: function(cls) {
+        var me = this,
+            baseClsUi = me.baseCls + '-' + me.ui + '-' + cls,
+            result = [Ext.baseCSSPrefix + cls, me.baseCls + '-' + cls, baseClsUi],
+            frameElementCls = me.frameElementCls,
+            frameElementsArray, frameElementsLength, i, el, frameElement, c;
+
+        if (me.frame && !Ext.supports.CSS3BorderRadius) {
+            
+            frameElementsArray = me.frameElementsArray;
+            frameElementsLength = frameElementsArray.length;
+            i = 0;
+
+            
+            for (; i < frameElementsLength; i++) {
+                frameElement = frameElementsArray[i];
+                el = me['frame' + frameElement.toUpperCase()];
+                c = baseClsUi + '-' + frameElement;
+                if (el && el.dom) {
+                    el.addCls(c);
+                } else {
+                    Ext.Array.remove(frameElementCls[frameElement], c);
+                }
+            }
+        }
+
+        me.frameElementCls = frameElementCls;
+
+        return result;
+    },
+
+    
+    addUIToElement: function() {
+        var me = this,
+            baseClsUI = me.baseCls + '-' + me.ui,
+            frameElementCls = me.frameElementCls,
+            frameElementsArray, frameElementsLength, i, el, frameElement, c;
+
+        me.addCls(baseClsUI);
+
+        if (me.frame && !Ext.supports.CSS3BorderRadius) {
+            
+            frameElementsArray = me.frameElementsArray;
+            frameElementsLength = frameElementsArray.length;
+            i = 0;
+
+            
+            for (; i < frameElementsLength; i++) {
+                frameElement = frameElementsArray[i];
+                el = me['frame' + frameElement.toUpperCase()];
+                c = baseClsUI + '-' + frameElement;
+                if (el) {
+                    el.addCls(c);
+                } else {
+                    if (!Ext.Array.contains(frameElementCls[frameElement], c)) {
+                        frameElementCls[frameElement].push(c);
+                    }
+                }
+            }
+        }
+    },
+
+    
+    removeUIFromElement: function() {
+        var me = this,
+            baseClsUI = me.baseCls + '-' + me.ui,
+            frameElementCls = me.frameElementCls,
+            frameElementsArray, frameElementsLength, i, el, frameElement, c;
+
+        me.removeCls(baseClsUI);
+
+        if (me.frame && !Ext.supports.CSS3BorderRadius) {
+            
+            frameElementsArray = me.frameElementsArray;
+            frameElementsLength = frameElementsArray.length;
+            i = 0;
+
+            for (; i < frameElementsLength; i++) {
+                frameElement = frameElementsArray[i];
+                el = me['frame' + frameElement.toUpperCase()];
+                c = baseClsUI + '-' + frameElement;
+                if (el) {
+                    el.removeCls(c);
+                } else {
+                    Ext.Array.remove(frameElementCls[frameElement], c);
+                }
+            }
+        }
+    },
+
+    
+    getTpl: function(name) {
+        return Ext.XTemplate.getTpl(this, name);
+    },
+
+    
+    initStyles: function(targetEl) {
+        var me = this,
+            Element = Ext.Element,
+            padding = me.padding,
+            margin = me.margin,
+            x = me.x,
+            y = me.y,
+            width, height;
+
+        
+        
+        if (padding !== undefined) {
+            targetEl.setStyle('padding', Element.unitizeBox((padding === true) ? 5 : padding));
+        }
+
+        if (margin !== undefined) {
+            targetEl.setStyle('margin', Element.unitizeBox((margin === true) ? 5 : margin));
+        }
+
+        if (me.border !== undefined) {
+            me.setBorder(me.border, targetEl);
+        }
+
+        
+        
+        if (me.cls && me.cls != me.initialCls) {
+            targetEl.addCls(me.cls);
+            delete me.cls;
+            delete me.initialCls;
+        }
+        if (me.style && me.style != me.initialStyle) {
+            targetEl.setStyle(me.style);
+            delete me.style;
+            delete me.initialStyle;
+        }
+
+        if (x !== undefined) {
+            targetEl.setStyle('left', (typeof x == 'number') ? (x + 'px') : x);
+        }
+        if (y !== undefined) {
+            targetEl.setStyle('top', (typeof y == 'number') ? (y + 'px') : y);
+        }
+
+        
+        
+        if (!me.getFrameInfo()) {
+            width = me.width;
+            height = me.height;
+
+            
+            if (width !== undefined) {
+                if (typeof width === 'number') {
+                    if (Ext.isBorderBox) {
+                        targetEl.setStyle('width', width + 'px');
+                    }
+                } else {
+                    targetEl.setStyle('width', width);
+                }
+            }
+            if (height !== undefined) {
+                if (typeof height === 'number') {
+                    if (Ext.isBorderBox) {
+                        targetEl.setStyle('height', height + 'px');
+                    }
+                } else {
+                    targetEl.setStyle('height', height);
+                }
+            }
+        }
+    },
+
+    
+    initEvents : function() {
+        var me = this,
+            afterRenderEvents = me.afterRenderEvents,
+            el,
+            property,
+            fn = function(listeners){
+                me.mon(el, listeners);
+            };
+
+        if (afterRenderEvents) {
+            for (property in afterRenderEvents) {
+                if (afterRenderEvents.hasOwnProperty(property)) {
+                    el = me[property];
+                    if (el && el.on) {
+                        Ext.each(afterRenderEvents[property], fn);
+                    }
+                }
+            }
+        }
+
+        
+        
+        
+        me.addFocusListener();
+    },
+
+    
+    addFocusListener: function() {
+        var me = this,
+            focusEl = me.getFocusEl(),
+            needsTabIndex;
+
+        
+        
+        
+        
+        
+        
+
+        
+        if (focusEl) {
+            
+            
+            if (focusEl.isComponent) {
+                return focusEl.addFocusListener();
+            }
+
+            
+            
+            
+            needsTabIndex = focusEl.needsTabIndex();
+            if (!me.focusListenerAdded && (!needsTabIndex || Ext.FocusManager.enabled)) {
+                if (needsTabIndex) {
+                    focusEl.dom.tabIndex = -1;
+                }
+                focusEl.on({
+                    focus: me.onFocus,
+                    blur: me.onBlur,
+                    scope: me
+                });
+                me.focusListenerAdded = true;
+            }
+        }
+    },
+
+    
+    getFocusEl: Ext.emptyFn,
+
+    isFocusable: function(c) {
+        var me = this,
+            focusEl;
+        if ((me.focusable !== false) && (focusEl = me.getFocusEl()) && me.rendered && !me.destroying && !me.isDestroyed && !me.disabled && me.isVisible(true)) {
+
+            
+            
+            if (focusEl.isComponent) {
+                return focusEl.isFocusable();
+            }
+
+            return focusEl && focusEl.dom && focusEl.isVisible();
+        }
+    },
+
+    
+    preFocus: Ext.emptyFn,
+
+    
+    onFocus: function(e) {
+        var me = this,
+            focusCls = me.focusCls,
+            focusEl = me.getFocusEl();
+
+        if (!me.disabled) {
+            me.preFocus(e);
+            if (focusCls && focusEl) {
+                focusEl.addCls(me.addClsWithUI(focusCls, true));
+            }
+            if (!me.hasFocus) {
+                me.hasFocus = true;
+                me.fireEvent('focus', me, e);
+            }
+        }
+    },
+
+    
+    beforeBlur : Ext.emptyFn,
+
+    
+    onBlur : function(e) {
+        var me = this,
+            focusCls = me.focusCls,
+            focusEl = me.getFocusEl();
+
+        if (me.destroying) {
+            return;
+        }
+
+        me.beforeBlur(e);
+        if (focusCls && focusEl) {
+            focusEl.removeCls(me.removeClsWithUI(focusCls, true));
+        }
+        if (me.validateOnBlur) {
+            me.validate();
+        }
+        me.hasFocus = false;
+        me.fireEvent('blur', me, e);
+        me.postBlur(e);
+    },
+
+    
+    postBlur : Ext.emptyFn,
+
+    
+    is: function(selector) {
+        return Ext.ComponentQuery.is(this, selector);
+    },
+
+    
+    up: function(selector) {
+        
+        
+        
+        var result = this.getBubbleTarget();
+        if (selector) {
+            for (; result; result = result.getBubbleTarget()) {
+                if (Ext.ComponentQuery.is(result, selector)) {
+                    return result;
+                }
+            }
+        }
+        return result;
+    },
+
+    
+    nextSibling: function(selector) {
+        var o = this.ownerCt, it, last, idx, c;
+        if (o) {
+            it = o.items;
+            idx = it.indexOf(this) + 1;
+            if (idx) {
+                if (selector) {
+                    for (last = it.getCount(); idx < last; idx++) {
+                        if ((c = it.getAt(idx)).is(selector)) {
+                            return c;
+                        }
+                    }
+                } else {
+                    if (idx < it.getCount()) {
+                        return it.getAt(idx);
+                    }
+                }
+            }
+        }
+        return null;
+    },
+
+    
+    previousSibling: function(selector) {
+        var o = this.ownerCt, it, idx, c;
+        if (o) {
+            it = o.items;
+            idx = it.indexOf(this);
+            if (idx != -1) {
+                if (selector) {
+                    for (--idx; idx >= 0; idx--) {
+                        if ((c = it.getAt(idx)).is(selector)) {
+                            return c;
+                        }
+                    }
+                } else {
+                    if (idx) {
+                        return it.getAt(--idx);
+                    }
+                }
+            }
+        }
+        return null;
+    },
+
+    
+    previousNode: function(selector,  includeSelf) {
+        var node = this,
+            ownerCt = node.ownerCt,
+            result,
+            it, i, sib;
+
+        
+        if (includeSelf && node.is(selector)) {
+            return node;
+        }
+
+        if (ownerCt) {
+            for (it = ownerCt.items.items, i = Ext.Array.indexOf(it, node) - 1; i > -1; i--) {
+                sib = it[i];
+                if (sib.query) {
+                    result = sib.query(selector);
+                    result = result[result.length - 1];
+                    if (result) {
+                        return result;
+                    }
+                }
+                if (sib.is(selector)) {
+                    return sib;
+                }
+            }
+            return ownerCt.previousNode(selector, true);
+        }
+        return null;
+    },
+
+    
+    nextNode: function(selector,  includeSelf) {
+        var node = this,
+            ownerCt = node.ownerCt,
+            result,
+            it, len, i, sib;
+
+        
+        if (includeSelf && node.is(selector)) {
+            return node;
+        }
+
+        if (ownerCt) {
+            for (it = ownerCt.items.items, i = Ext.Array.indexOf(it, node) + 1, len = it.length; i < len; i++) {
+                sib = it[i];
+                if (sib.is(selector)) {
+                    return sib;
+                }
+                if (sib.down) {
+                    result = sib.down(selector);
+                    if (result) {
+                        return result;
+                    }
+                }
+            }
+            return ownerCt.nextNode(selector);
+        }
+        return null;
+    },
+
+    
+    getId : function() {
+        return this.id || (this.id = 'ext-comp-' + (this.getAutoId()));
+    },
+
+    
+    getItemId : function() {
+        return this.itemId || this.id;
+    },
+
+    
+    getEl : function() {
+        return this.el;
+    },
+
+    
+    getTargetEl: function() {
+        return this.frameBody || this.el;
+    },
+
+    
+    getOverflowStyle: function() {
+        var me = this,
+            result = null;
+
+        if (typeof me.autoScroll == 'boolean') {
+            result = {
+                overflow: me.autoScroll ? 'auto' : ''
+            };
+        } else if (me.overflowX !== undefined || me.overflowY !== undefined) {
+            result = {
+                'overflow-x':  (me.overflowX||''),
+                'overflow-y':  (me.overflowY||'')
+            };
+        }
+
+        
+        
+        if (result && (Ext.isIE6 || Ext.isIE7)) {
+            result.position = 'relative';
+        }
+
+        return result;
+    },
+
+    
+    isXType: function(xtype, shallow) {
+        if (shallow) {
+            return this.xtype === xtype;
+        }
+        else {
+            return this.xtypesMap[xtype];
+        }
+    },
+
+    
+    getXTypes: function() {
+        var self = this.self,
+            xtypes, parentPrototype, parentXtypes;
+
+        if (!self.xtypes) {
+            xtypes = [];
+            parentPrototype = this;
+
+            while (parentPrototype) {
+                parentXtypes = parentPrototype.xtypes;
+
+                if (parentXtypes !== undefined) {
+                    xtypes.unshift.apply(xtypes, parentXtypes);
+                }
+
+                parentPrototype = parentPrototype.superclass;
+            }
+
+            self.xtypeChain = xtypes;
+            self.xtypes = xtypes.join('/');
+        }
+
+        return self.xtypes;
+    },
+
+    
+    update : function(htmlOrData, loadScripts, cb) {
+        var me = this;
+
+        if (me.tpl && !Ext.isString(htmlOrData)) {
+            me.data = htmlOrData;
+            if (me.rendered) {
+                me.tpl[me.tplWriteMode](me.getTargetEl(), htmlOrData || {});
+            }
+        } else {
+            me.html = Ext.isObject(htmlOrData) ? Ext.DomHelper.markup(htmlOrData) : htmlOrData;
+            if (me.rendered) {
+                me.getTargetEl().update(me.html, loadScripts, cb);
+            }
+        }
+
+        if (me.rendered) {
+            me.updateLayout();
+        }
+    },
+
+    
+    setVisible : function(visible) {
+        return this[visible ? 'show': 'hide']();
+    },
+
+    
+    isVisible: function(deep) {
+        var me = this,
+            child = me,
+            visible = me.rendered && !me.hidden,
+            ancestor = me.ownerCt;
+
+        
+        me.hiddenAncestor = false;
+        if (me.destroyed) {
+            return false;
+        }
+
+        if (deep && visible && ancestor) {
+            while (ancestor) {
+                
+                
+                
+                
+                if (ancestor.hidden || (ancestor.collapsed &&
+                        !(ancestor.getDockedItems && Ext.Array.contains(ancestor.getDockedItems(), child)))) {
+                    
+                    me.hiddenAncestor = ancestor;
+                    visible = false;
+                    break;
+                }
+                child = ancestor;
+                ancestor = ancestor.ownerCt;
+            }
+        }
+        return visible;
+    },
+
+    onBoxReady: function(){
+        var me = this;
+
+        if (me.disableOnBoxReady) {
+            me.onDisable();
+        } else if (me.enableOnBoxReady) {
+            me.onEnable();
+        }
+        if (me.resizable) {
+            me.initResizable(me.resizable);
+        }
+
+        
+        
+        if (me.draggable) {
+            me.initDraggable();
+        }
+    },
+
+    
+    enable: function(silent) {
+        var me = this;
+
+        delete me.disableOnBoxReady;
+        me.removeCls(me.disabledCls);
+        if (me.rendered) {
+            me.onEnable();
+        } else {
+            me.enableOnBoxReady = true;
+        }
+
+        me.disabled = false;
+        delete me.resetDisable;
+
+        if (silent !== true) {
+            me.fireEvent('enable', me);
+        }
+
+        return me;
+    },
+
+    
+    disable: function(silent) {
+        var me = this;
+
+        delete me.enableOnBoxReady;
+        me.addCls(me.disabledCls);
+        if (me.rendered) {
+            me.onDisable();
+        } else {
+            me.disableOnBoxReady = true;
+        }
+
+        me.disabled = true;
+
+        if (silent !== true) {
+            delete me.resetDisable;
+            me.fireEvent('disable', me);
+        }
+
+        return me;
+    },
+
+    
+    onEnable: function() {
+        if (this.maskOnDisable) {
+            this.el.dom.disabled = false;
+            this.unmask();
+        }
+    },
+
+    
+    onDisable : function() {
+        var me = this,
+            focusCls = me.focusCls,
+            focusEl = me.getFocusEl();
+            
+        if (focusCls && focusEl) {
+            focusEl.removeCls(me.removeClsWithUI(focusCls, true));
+        }
+        
+        if (me.maskOnDisable) {
+            me.el.dom.disabled = true;
+            me.mask();
+        }
+    },
+
+    mask: function() {
+        var box = this.lastBox,
+            target = this.getMaskTarget(),
+            args = [];
+
+        
+        if (box) {
+            args[2] = box.height;
+        }
+        target.mask.apply(target, args);
+    },
+
+    unmask: function() {
+        this.getMaskTarget().unmask();
+    },
+
+    getMaskTarget: function(){
+        return this.el;
+    },
+
+    
+    isDisabled : function() {
+        return this.disabled;
+    },
+
+    
+    setDisabled : function(disabled) {
+        return this[disabled ? 'disable': 'enable']();
+    },
+
+    
+    isHidden : function() {
+        return this.hidden;
+    },
+
+    
+    addCls : function(cls) {
+        var me = this,
+            el = me.rendered ? me.el : me.protoEl;
+
+        el.addCls.apply(el, arguments);
+        return me;
+    },
+
+    
+    addClass : function() {
+        return this.addCls.apply(this, arguments);
+    },
+
+    
+    hasCls: function (cls) {
+        var me = this,
+            el = me.rendered ? me.el : me.protoEl;
+
+        return el.hasCls.apply(el, arguments);
+    },
+
+    
+    removeCls : function(cls) {
+        var me = this,
+            el = me.rendered ? me.el : me.protoEl;
+
+        el.removeCls.apply(el, arguments);
+        return me;
+    },
+
+
+    addOverCls: function() {
+        var me = this;
+        if (!me.disabled) {
+            me.el.addCls(me.overCls);
+        }
+    },
+
+    removeOverCls: function() {
+        this.el.removeCls(this.overCls);
+    },
+
+    addListener : function(element, listeners, scope, options) {
+        var me = this,
+            fn,
+            option;
+
+        if (Ext.isString(element) && (Ext.isObject(listeners) || options && options.element)) {
+            if (options.element) {
+                fn = listeners;
+
+                listeners = {};
+                listeners[element] = fn;
+                element = options.element;
+                if (scope) {
+                    listeners.scope = scope;
+                }
+
+                for (option in options) {
+                    if (options.hasOwnProperty(option)) {
+                        if (me.eventOptionsRe.test(option)) {
+                            listeners[option] = options[option];
+                        }
+                    }
+                }
+            }
+
+            
+            
+            if (me[element] && me[element].on) {
+                me.mon(me[element], listeners);
+            } else {
+                me.afterRenderEvents = me.afterRenderEvents || {};
+                if (!me.afterRenderEvents[element]) {
+                    me.afterRenderEvents[element] = [];
+                }
+                me.afterRenderEvents[element].push(listeners);
+            }
+        }
+
+        return me.mixins.observable.addListener.apply(me, arguments);
+    },
+
+    
+    removeManagedListenerItem: function(isClear, managedListener, item, ename, fn, scope){
+        var me = this,
+            element = managedListener.options ? managedListener.options.element : null;
+
+        if (element) {
+            element = me[element];
+            if (element && element.un) {
+                if (isClear || (managedListener.item === item && managedListener.ename === ename && (!fn || managedListener.fn === fn) && (!scope || managedListener.scope === scope))) {
+                    element.un(managedListener.ename, managedListener.fn, managedListener.scope);
+                    if (!isClear) {
+                        Ext.Array.remove(me.managedListeners, managedListener);
+                    }
+                }
+            }
+        } else {
+            return me.mixins.observable.removeManagedListenerItem.apply(me, arguments);
+        }
+    },
+
+    
+    getBubbleTarget : function() {
+        return this.ownerCt;
+    },
+
+    
+    isFloating : function() {
+        return this.floating;
+    },
+
+    
+    isDraggable : function() {
+        return !!this.draggable;
+    },
+
+    
+    isDroppable : function() {
+        return !!this.droppable;
+    },
+
+    
+    onAdded : function(container, pos) {
+        var me = this;
+        me.ownerCt = container;
+        if (me.hasListeners.added) {
+            me.fireEvent('added', me, container, pos);
+        }
+    },
+
+    
+    onRemoved : function(destroying) {
+        var me = this;
+        if (me.hasListeners.removed) {
+            me.fireEvent('removed', me, me.ownerCt);
+        }
+        delete me.ownerCt;
+        delete me.ownerLayout;
+    },
+
+    
+    beforeDestroy : Ext.emptyFn,
+
+    
+    onResize : Ext.emptyFn,
+
+    
+    setSize : function(width, height) {
+        var me = this;
+
+        
+        if (width && typeof width == 'object') {
+            height = width.height;
+            width  = width.width;
+        }
+
+        
+        if (typeof width == 'number') {
+            me.width = Ext.Number.constrain(width, me.minWidth, me.maxWidth);
+        } else if (width === null) {
+            delete me.width;
+        }
+        
+        if (typeof height == 'number') {
+            me.height = Ext.Number.constrain(height, me.minHeight, me.maxHeight);
+        } else if (height === null) {
+            delete me.height;
+        }
+
+        
+        
+        if (me.rendered && me.isVisible()) {
+
+            
+            me.updateLayout({
+                isRoot: false
+            });
+        }
+
+        return me;
+    },
+
+    
+    isLayoutRoot: function() {
+        var me = this,
+            ownerLayout = me.ownerLayout;
+
+        
+        
+        
+        
+        if (!ownerLayout || me._isLayoutRoot || me.floating) {
+            return true;
+        }
+
+        return ownerLayout.isItemLayoutRoot(me);
+    },
+
+    
+    isLayoutSuspended: function () {
+        var comp = this,
+            ownerLayout;
+
+        while (comp) {
+            if (comp.layoutSuspendCount || comp.suspendLayout) {
+                return true;
+            }
+
+            ownerLayout = comp.ownerLayout;
+            if (!ownerLayout) {
+                break;
+            }
+
+            
+
+            
+            
+            
+            comp = ownerLayout.owner;
+        }
+
+        return false;
+    },
+
+    
+    updateLayout: function (options) {
+        var me = this,
+            defer,
+            isRoot = options && options.isRoot;
+
+        if (!me.rendered || me.layoutSuspendCount || me.suspendLayout) {
+            return;
+        }
+
+        if (me.hidden) {
+            Ext.AbstractComponent.cancelLayout(me);
+        } else if (typeof isRoot != 'boolean') {
+            isRoot = me.isLayoutRoot();
+        }
+
+        
+        if (isRoot || !me.ownerLayout || !me.ownerLayout.onContentChange(me)) {
+            
+            if (!me.isLayoutSuspended()) {
+                
+                defer = (options && options.hasOwnProperty('defer')) ? options.defer : me.deferLayouts;
+                Ext.AbstractComponent.updateLayout(me, defer);
+            }
+        }
+    },
+
+    
+    getSizeModel: function (ownerCtSizeModel) {
+        var me = this,
+            models = Ext.layout.SizeModel,
+            ownerContext = me.componentLayout.ownerContext,
+            width = me.width,
+            height = me.height,
+            typeofWidth, typeofHeight,
+            hasPixelWidth, hasPixelHeight,
+            heightModel, ownerLayout, policy, shrinkWrap, topLevel, widthModel;
+
+        if (ownerContext) {
+            
+            
+            
+            
+            widthModel = ownerContext.widthModel;
+            heightModel = ownerContext.heightModel;
+        }
+
+        if (!widthModel || !heightModel) {
+            hasPixelWidth = ((typeofWidth = typeof width) == 'number');
+            hasPixelHeight = ((typeofHeight = typeof height) == 'number');
+            topLevel = me.floating || !(ownerLayout = me.ownerLayout);
+
+            
+            if (topLevel) {
+                policy = Ext.layout.Layout.prototype.autoSizePolicy;
+                shrinkWrap = me.floating ? 3 : me.shrinkWrap;
+
+                if (hasPixelWidth) {
+                    widthModel = models.configured;
+                }
+
+                if (hasPixelHeight) {
+                    heightModel = models.configured;
+                }
+            } else {
+                policy = ownerLayout.getItemSizePolicy(me, ownerCtSizeModel);
+                shrinkWrap = ownerLayout.isItemShrinkWrap(me);
+            }
+
+            shrinkWrap = (shrinkWrap === true) ? 3 : (shrinkWrap || 0); 
+
+            
+            
+            
+            
+            if (topLevel && shrinkWrap) {
+                if (width && typeofWidth == 'string') {
+                    shrinkWrap &= 2; 
+                }
+                if (height && typeofHeight == 'string') {
+                    shrinkWrap &= 1; 
+                }
+            }
+
+            if (shrinkWrap !== 3) {
+                if (!ownerCtSizeModel) {
+                    ownerCtSizeModel = me.ownerCt && me.ownerCt.getSizeModel();
+                }
+
+                if (ownerCtSizeModel) {
+                    shrinkWrap |= (ownerCtSizeModel.width.shrinkWrap ? 1 : 0) | (ownerCtSizeModel.height.shrinkWrap ? 2 : 0);
+                }
+            }
+
+            if (!widthModel) {
+                if (!policy.setsWidth) {
+                    if (hasPixelWidth) {
+                        widthModel = models.configured;
+                    } else {
+                        widthModel = (shrinkWrap & 1) ? models.shrinkWrap : models.natural;
+                    }
+                } else if (policy.readsWidth) {
+                    if (hasPixelWidth) {
+                        widthModel = models.calculatedFromConfigured;
+                    } else {
+                        widthModel = (shrinkWrap & 1) ? models.calculatedFromShrinkWrap :
+                                    models.calculatedFromNatural;
+                    }
+                } else {
+                    widthModel = models.calculated;
+                }
+            }
+
+            if (!heightModel) {
+                if (!policy.setsHeight) {
+                    if (hasPixelHeight) {
+                        heightModel = models.configured;
+                    } else {
+                        heightModel = (shrinkWrap & 2) ? models.shrinkWrap : models.natural;
+                    }
+                } else if (policy.readsHeight) {
+                    if (hasPixelHeight) {
+                        heightModel = models.calculatedFromConfigured;
+                    } else {
+                        heightModel = (shrinkWrap & 2) ? models.calculatedFromShrinkWrap :
+                                    models.calculatedFromNatural;
+                    }
+                } else {
+                    heightModel = models.calculated;
+                }
+            }
+        }
+
+        
+        
+        return widthModel.pairsByHeightOrdinal[heightModel.ordinal];
+    },
+
+    isDescendant: function(ancestor) {
+        if (ancestor.isContainer) {
+            for (var c = this.ownerCt; c; c = c.ownerCt) {
+                if (c === ancestor) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    },
+
+    
+    doComponentLayout : function() {
+        this.updateLayout();
+        return this;
+    },
+
+    
+    forceComponentLayout: function () {
+        this.updateLayout();
+    },
+
+    
+    setComponentLayout : function(layout) {
+        var currentLayout = this.componentLayout;
+        if (currentLayout && currentLayout.isLayout && currentLayout != layout) {
+            currentLayout.setOwner(null);
+        }
+        this.componentLayout = layout;
+        layout.setOwner(this);
+    },
+
+    getComponentLayout : function() {
+        var me = this;
+
+        if (!me.componentLayout || !me.componentLayout.isLayout) {
+            me.setComponentLayout(Ext.layout.Layout.create(me.componentLayout, 'autocomponent'));
+        }
+        return me.componentLayout;
+    },
+
+    
+    afterComponentLayout: function(width, height, oldWidth, oldHeight) {
+        var me = this,
+            floaters, len, i, floater;
+
+        if (++me.componentLayoutCounter === 1) {
+            me.afterFirstLayout(width, height);
+        }
+
+        
+        if (me.floatingItems) {
+            floaters = me.floatingItems.items;
+            len = floaters.length;
+            for (i = 0; i < len; i++) {
+                floater = floaters[i];
+                if (!floater.rendered && floater.autoShow) {
+                    floater.show();
+                }
+            }
+        }
+        if (me.hasListeners.resize && (width !== oldWidth || height !== oldHeight)) {
+            me.fireEvent('resize', me, width, height, oldWidth, oldHeight);
+        }
+    },
+
+    
+    beforeComponentLayout: function(width, height) {
+        return true;
+    },
+
+    
+    setPosition : function(x, y, animate) {
+        var me = this,
+            pos = me.beforeSetPosition.apply(me, arguments);
+
+        if (pos && me.rendered) {
+            
+            pos = me.convertPosition(pos);
+
+            
+            if (pos.left !== me.el.getLeft() || pos.top !== me.el.getTop()) {
+                if (animate) {
+                    me.stopAnimation();
+                    me.animate(Ext.apply({
+                        duration: 1000,
+                        listeners: {
+                            afteranimate: Ext.Function.bind(me.afterSetPosition, me, [pos.left, pos.top])
+                        },
+                        to: pos
+                    }, animate));
+                } else {
+                    
+                    
+                    if (pos.left !== undefined && pos.top !== undefined) {
+                        me.el.setLeftTop(pos.left, pos.top);
+                    } else if (pos.left !== undefined) {
+                        me.el.setLeft(pos.left);
+                    } else if (pos.top !==undefined) {
+                        me.el.setTop(pos.top);
+                    }
+                    me.afterSetPosition(pos.left, pos.top);
+                }
+            }
+        }
+        return me;
+    },
+
+    
+    beforeSetPosition: function (x, y, animate) {
+        var pos, x0;
+
+        
+        if (!x || Ext.isNumber(x)) {
+            pos = { x: x, y : y, anim: animate };
+        } else if (Ext.isNumber(x0 = x[0])) { 
+            pos = { x : x0, y : x[1], anim: y };
+        } else {
+            pos = { x: x.x, y: x.y, anim: y }; 
+        }
+
+        pos.hasX = Ext.isNumber(pos.x);
+        pos.hasY = Ext.isNumber(pos.y);
+
+        
+        this.x = pos.x;
+        this.y = pos.y;
+
+        return (pos.hasX || pos.hasY) ? pos : null;
+    },
+
+    
+    afterSetPosition: function(x, y) {
+        var me = this;
+        me.onPosition(x, y);
+        if (me.hasListeners.move) {
+            me.fireEvent('move', me, x, y);
+        }
+    },
+
+    
+    convertPosition: function (pos, withUnits) {
+        var ret = {},
+            El = Ext.Element;
+
+        if (pos.hasX) {
+            ret.left = withUnits ? El.addUnits(pos.x) : pos.x;
+        }
+        if (pos.hasY) {
+            ret.top = withUnits ? El.addUnits(pos.y) : pos.y;
+        }
+
+        return ret;
+    },
+
+    
+    onPosition: Ext.emptyFn,
+
+    
+    setWidth : function(width) {
+        return this.setSize(width);
+    },
+
+    
+    setHeight : function(height) {
+        return this.setSize(undefined, height);
+    },
+
+    
+    getSize : function() {
+        return this.el.getSize();
+    },
+
+    
+    getWidth : function() {
+        return this.el.getWidth();
+    },
+
+    
+    getHeight : function() {
+        return this.el.getHeight();
+    },
+
+    
+    getLoader: function(){
+        var me = this,
+            autoLoad = me.autoLoad ? (Ext.isObject(me.autoLoad) ? me.autoLoad : {url: me.autoLoad}) : null,
+            loader = me.loader || autoLoad;
+
+        if (loader) {
+            if (!loader.isLoader) {
+                me.loader = new Ext.ComponentLoader(Ext.apply({
+                    target: me,
+                    autoLoad: autoLoad
+                }, loader));
+            } else {
+                loader.setTarget(me);
+            }
+            return me.loader;
+
+        }
+        return null;
+    },
+
+    
+    setDocked : function(dock, layoutParent) {
+        var me = this;
+
+        me.dock = dock;
+        if (layoutParent && me.ownerCt && me.rendered) {
+            me.ownerCt.updateLayout();
+        }
+        return me;
+    },
+
+    
+    setBorder: function(border,  targetEl) {
+        var me = this,
+            initial = !!targetEl;
+
+        if (me.rendered || initial) {
+            if (!initial) {
+                targetEl = me.el;
+            }
+
+            if (!border) {
+                border = 0;
+            } else {
+                border = Ext.Element.unitizeBox((border === true) ? 1 : border);
+            }
+            targetEl.setStyle('border-width', border);
+            if (!initial) {
+                me.updateLayout();
+            }
+        }
+        me.border = border;
+    },
+
+    onDestroy : function() {
+        var me = this;
+
+        if (me.monitorResize && Ext.EventManager.resizeEvent) {
+            Ext.EventManager.resizeEvent.removeListener(me.setSize, me);
+        }
+
+        
+        Ext.destroy(
+            me.componentLayout,
+            me.loadMask,
+            me.floatingDescendants
+        );
+    },
+
+    
+    destroy : function() {
+        var me = this,
+            selectors = me.renderSelectors,
+            selector,
+            el;
+
+        if (!me.isDestroyed) {
+            if (!me.hasListeners.beforedestroy || me.fireEvent('beforedestroy', me) !== false) {
+                me.destroying = true;
+                me.beforeDestroy();
+
+                if (me.floating) {
+                    delete me.floatParent;
+                    
+                    
+                    if (me.zIndexManager) {
+                        me.zIndexManager.unregister(me);
+                    }
+                } else if (me.ownerCt && me.ownerCt.remove) {
+                    me.ownerCt.remove(me, false);
+                }
+
+                me.onDestroy();
+
+                
+                Ext.destroy(me.plugins);
+
+                if (me.hasListeners.destroy) {
+                    me.fireEvent('destroy', me);
+                }
+                Ext.ComponentManager.unregister(me);
+
+                me.mixins.state.destroy.call(me);
+
+                me.clearListeners();
+                
+                if (me.rendered) {
+                    if (!me.preserveElOnDestroy) {
+                        me.el.remove();
+                    }
+                    me.mixins.elementCt.destroy.call(me); 
+                    if (selectors) {
+                        for (selector in selectors) {
+                            if (selectors.hasOwnProperty(selector)) {
+                                el = me[selector];
+                                if (el) { 
+                                    delete me[selector];
+                                    el.remove();
+                                }
+                            }
+                        }
+                    }
+
+                    delete me.el;
+                    delete me.frameBody;
+                    delete me.rendered;
+                }
+
+                me.destroying = false;
+                me.isDestroyed = true;
+            }
+        }
+    },
+
+    
+    getPlugin: function(pluginId) {
+        var i = 0,
+            plugins = this.plugins,
+            ln = plugins.length;
+        for (; i < ln; i++) {
+            if (plugins[i].pluginId === pluginId) {
+                return plugins[i];
+            }
+        }
+    },
+
+    
+    isDescendantOf: function(container) {
+        return !!this.findParentBy(function(p){
+            return p === container;
+        });
+    }
+}, function() {
+    var AbstractComponent = this;
+
+    AbstractComponent.createAlias({
+        on: 'addListener',
+        prev: 'previousSibling',
+        next: 'nextSibling'
+    });
+
+    
+    Ext.resumeLayouts = function (flush) {
+        AbstractComponent.resumeLayouts(flush);
+    };
+
+    
+    Ext.suspendLayouts = function () {
+        AbstractComponent.suspendLayouts();
+    };
+
+    
+    Ext.batchLayouts = function(fn, scope) {
+        AbstractComponent.suspendLayouts();
+        
+        fn.call(scope);
+        AbstractComponent.resumeLayouts(true);
+    };
+});
+
+
+Ext.define('Ext.AbstractPlugin', {
+    disabled: false,
+
+    constructor: function(config) {
+        this.initialConfig = config;
+        Ext.apply(this, config);
+    },
+
+    clone: function() {
+        return new this.self(this.initialConfig);
+    },
+
+    getCmp: function() {
+        return this.cmp;
+    },
+
+    
+
+    
+    init: Ext.emptyFn,
+
+    
+    destroy: Ext.emptyFn,
+
+    
+    enable: function() {
+        this.disabled = false;
+    },
+
+    
+    disable: function() {
+        this.disabled = true;
+    }
+});
+
+
+Ext.define('Ext.Action', {
+
+    
+
+    
+
+    
+    
+    
+    
+    
+    
+    
+
+    
+    constructor : function(config){
+        this.initialConfig = config;
+        this.itemId = config.itemId = (config.itemId || config.id || Ext.id());
+        this.items = [];
+    },
+
+    
+    isAction : true,
+
+    
+    setText : function(text){
+        this.initialConfig.text = text;
+        this.callEach('setText', [text]);
+    },
+
+    
+    getText : function(){
+        return this.initialConfig.text;
+    },
+
+    
+    setIconCls : function(cls){
+        this.initialConfig.iconCls = cls;
+        this.callEach('setIconCls', [cls]);
+    },
+
+    
+    getIconCls : 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 items = this.items,
+            i = 0,
+            len = items.length,
+            item;
+
+        Ext.suspendLayouts();
+        for(; i < len; i++){
+            item = items[i];
+            item[fnName].apply(item, args);
+        }
+        Ext.resumeLayouts(true);
+    },
+
+    
+    addComponent : function(comp){
+        this.items.push(comp);
+        comp.on('destroy', this.removeComponent, this);
+    },
+
+    
+    removeComponent : function(comp){
+        Ext.Array.remove(this.items, comp);
+    },
+
+    
+    execute : function(){
+        this.initialConfig.handler.apply(this.initialConfig.scope || Ext.global, arguments);
+    }
+});
+
+
+Ext.define('Ext.data.Connection', {
+    mixins: {
+        observable: 'Ext.util.Observable'
+    },
+
+    statics: {
+        requestId: 0
+    },
+
+    url: null,
+    async: true,
+    method: null,
+    username: '',
+    password: '',
+
+    
+    disableCaching: true,
+
+    
+    withCredentials: false,
+
+    
+    cors: false,
+
+    
+    disableCachingParam: '_dc',
+
+    
+    timeout : 30000,
+
+    
+
+    
+
+    
+
+    
+
+    useDefaultHeader : true,
+    defaultPostHeader : 'application/x-www-form-urlencoded; charset=UTF-8',
+    useDefaultXhrHeader : true,
+    defaultXhrHeader : 'XMLHttpRequest',
+
+    constructor : function(config) {
+        config = config || {};
+        Ext.apply(this, config);
+
+        
+        
+        
+        this.requests = {};
+        this.mixins.observable.constructor.call(this);
+    },
+
+    
+    request : function(options) {
+        options = options || {};
+        var me = this,
+            scope = options.scope || window,
+            username = options.username || me.username,
+            password = options.password || me.password || '',
+            async,
+            requestOptions,
+            request,
+            headers,
+            xhr;
+
+        if (me.fireEvent('beforerequest', me, options) !== false) {
+
+            requestOptions = me.setOptions(options, scope);
+
+            if (me.isFormUpload(options)) {
+                me.upload(options.form, requestOptions.url, requestOptions.data, options);
+                return null;
+            }
+
+            
+            if (options.autoAbort || me.autoAbort) {
+                me.abort();
+            }
+
+            
+            async = options.async !== false ? (options.async || me.async) : false;
+            xhr = me.openRequest(options, requestOptions, async, username, password);
+
+            headers = me.setupHeaders(xhr, options, requestOptions.data, requestOptions.params);
+
+            
+            request = {
+                id: ++Ext.data.Connection.requestId,
+                xhr: xhr,
+                headers: headers,
+                options: options,
+                async: async,
+                timeout: setTimeout(function() {
+                    request.timedout = true;
+                    me.abort(request);
+                }, options.timeout || me.timeout)
+            };
+            me.requests[request.id] = request;
+            me.latestId = request.id;
+            
+            if (async) {
+                xhr.onreadystatechange = Ext.Function.bind(me.onStateChange, me, [request]);
+            }
+
+            
+            xhr.send(requestOptions.data);
+            if (!async) {
+                return me.onComplete(request);
+            }
+            return request;
+        } else {
+            Ext.callback(options.callback, options.scope, [options, undefined, undefined]);
+            return null;
+        }
+    },
+
+    
+    upload: function(form, url, params, options) {
+        form = Ext.getDom(form);
+        options = options || {};
+
+        var id = Ext.id(),
+            frame = document.createElement('iframe'),
+            hiddens = [],
+            encoding = 'multipart/form-data',
+            buf = {
+                target: form.target,
+                method: form.method,
+                encoding: form.encoding,
+                enctype: form.enctype,
+                action: form.action
+            },
+            addField = function(name, value) {
+                hiddenItem = document.createElement('input');
+                Ext.fly(hiddenItem).set({
+                    type: 'hidden',
+                    value: value,
+                    name: name
+                });
+                form.appendChild(hiddenItem);
+                hiddens.push(hiddenItem);
+            },
+            hiddenItem, obj, value, name, vLen, v, hLen, h;
+
+        
+        Ext.fly(frame).set({
+            id: id,
+            name: id,
+            cls: Ext.baseCSSPrefix + 'hide-display',
+            src: Ext.SSL_SECURE_URL
+        });
+
+        document.body.appendChild(frame);
+
+        
+        if (document.frames) {
+            document.frames[id].name = id;
+        }
+
+        Ext.fly(form).set({
+            target: id,
+            method: 'POST',
+            enctype: encoding,
+            encoding: encoding,
+            action: url || buf.action
+        });
+
+        
+        if (params) {
+            obj = Ext.Object.fromQueryString(params) || {};
+
+            for (name in obj) {
+                if (obj.hasOwnProperty(name)) {
+                    value = obj[name];  
+                    if (Ext.isArray(value)) {
+                        vLen = value.length;
+                        for (v = 0; v < vLen; v++) {
+                            addField(name, value[v]);
+                        }
+                    } else {
+                        addField(name, value);
+                    }
+                }
+            }
+        }
+
+        Ext.fly(frame).on('load', Ext.Function.bind(this.onUploadComplete, this, [frame, options]), null, {single: true});
+        form.submit();
+
+        Ext.fly(form).set(buf);
+
+        hLen = hiddens.length;
+
+        for (h = 0; h < hLen; h++) {
+            Ext.removeNode(hiddens[h]);
+        }
+    },
+
+    
+    onUploadComplete: function(frame, options) {
+        var me = this,
+            
+            response = {
+                responseText: '',
+                responseXML: null
+            }, doc, contentNode;
+
+        try {
+            doc = frame.contentWindow.document || frame.contentDocument || window.frames[frame.id].document;
+            if (doc) {
+                if (doc.body) {
+
+                    
+                    
+                    if ((contentNode = doc.body.firstChild) && /pre/i.test(contentNode.tagName)) {
+                        response.responseText = contentNode.innerText;
+                    }
+
+                    
+                    
+                    else if (contentNode = doc.getElementsByTagName('textarea')[0]) {
+                        response.responseText = contentNode.value;
+                    }
+                    
+                    else {
+                        response.responseText = doc.body.textContent || doc.body.innerText;
+                    }
+                }
+                
+                response.responseXML = doc.XMLDocument || doc;
+            }
+        } catch (e) {
+        }
+
+        me.fireEvent('requestcomplete', me, response, options);
+
+        Ext.callback(options.success, options.scope, [response, options]);
+        Ext.callback(options.callback, options.scope, [options, true, response]);
+
+        setTimeout(function() {
+            Ext.removeNode(frame);
+        }, 100);
+    },
+
+    
+    isFormUpload: function(options) {
+        var form = this.getForm(options);
+        if (form) {
+            return (options.isUpload || (/multipart\/form-data/i).test(form.getAttribute('enctype')));
+        }
+        return false;
+    },
+
+    
+    getForm: function(options) {
+        return Ext.getDom(options.form) || null;
+    },
+
+    
+    setOptions: function(options, scope) {
+        var me = this,
+            params = options.params || {},
+            extraParams = me.extraParams,
+            urlParams = options.urlParams,
+            url = options.url || me.url,
+            jsonData = options.jsonData,
+            method,
+            disableCache,
+            data;
+
+
+        
+        if (Ext.isFunction(params)) {
+            params = params.call(scope, options);
+        }
+
+        
+        if (Ext.isFunction(url)) {
+            url = url.call(scope, options);
+        }
+
+        url = this.setupUrl(options, url);
+
+
+        
+        data = options.rawData || options.xmlData || jsonData || null;
+        if (jsonData && !Ext.isPrimitive(jsonData)) {
+            data = Ext.encode(data);
+        }
+
+        
+        if (Ext.isObject(params)) {
+            params = Ext.Object.toQueryString(params);
+        }
+
+        if (Ext.isObject(extraParams)) {
+            extraParams = Ext.Object.toQueryString(extraParams);
+        }
+
+        params = params + ((extraParams) ? ((params) ? '&' : '') + extraParams : '');
+
+        urlParams = Ext.isObject(urlParams) ? Ext.Object.toQueryString(urlParams) : urlParams;
+
+        params = this.setupParams(options, params);
+
+        
+        method = (options.method || me.method || ((params || data) ? 'POST' : 'GET')).toUpperCase();
+        this.setupMethod(options, method);
+
+
+        disableCache = options.disableCaching !== false ? (options.disableCaching || me.disableCaching) : false;
+        
+        if (method === 'GET' && disableCache) {
+            url = Ext.urlAppend(url, (options.disableCachingParam || me.disableCachingParam) + '=' + (new Date().getTime()));
+        }
+
+        
+        if ((method == 'GET' || data) && params) {
+            url = Ext.urlAppend(url, params);
+            params = null;
+        }
+
+        
+        if (urlParams) {
+            url = Ext.urlAppend(url, urlParams);
+        }
+
+        return {
+            url: url,
+            method: method,
+            data: data || params || null
+        };
+    },
+
+    
+    setupUrl: function(options, url) {
+        var form = this.getForm(options);
+        if (form) {
+            url = url || form.action;
+        }
+        return url;
+    },
+
+
+    
+    setupParams: function(options, params) {
+        var form = this.getForm(options),
+            serializedForm;
+        if (form && !this.isFormUpload(options)) {
+            serializedForm = Ext.Element.serializeForm(form);
+            params = params ? (params + '&' + serializedForm) : serializedForm;
+        }
+        return params;
+    },
+
+    
+    setupMethod: function(options, method) {
+        if (this.isFormUpload(options)) {
+            return 'POST';
+        }
+        return method;
+    },
+
+    
+    setupHeaders: function(xhr, options, data, params) {
+        var me = this,
+            headers = Ext.apply({}, options.headers || {}, me.defaultHeaders || {}),
+            contentType = me.defaultPostHeader,
+            jsonData = options.jsonData,
+            xmlData = options.xmlData,
+            key,
+            header;
+
+        if (!headers['Content-Type'] && (data || params)) {
+            if (data) {
+                if (options.rawData) {
+                    contentType = 'text/plain';
+                } else {
+                    if (xmlData && Ext.isDefined(xmlData)) {
+                        contentType = 'text/xml';
+                    } else if (jsonData && Ext.isDefined(jsonData)) {
+                        contentType = 'application/json';
+                    }
+                }
+            }
+            headers['Content-Type'] = contentType;
+        }
+
+        if (me.useDefaultXhrHeader && !headers['X-Requested-With']) {
+            headers['X-Requested-With'] = me.defaultXhrHeader;
+        }
+        
+        try {
+            for (key in headers) {
+                if (headers.hasOwnProperty(key)) {
+                    header = headers[key];
+                    xhr.setRequestHeader(key, header);
+                }
+
+            }
+        } catch(e) {
+            me.fireEvent('exception', key, header);
+        }
+        return headers;
+    },
+
+    
+    newRequest: function (options) {
+        var xhr;
+
+        if ((options.cors || this.cors) && Ext.isIE && Ext.ieVersion >= 8) {
+            xhr = new XDomainRequest();
+        } else {
+            xhr = this.getXhrInstance();
+        }
+
+        return xhr;
+    },
+
+    
+    openRequest: function (options, requestOptions, async, username, password) {
+        var xhr = this.newRequest(options);
+
+        if (username) {
+            xhr.open(requestOptions.method, requestOptions.url, async, username, password);
+        } else {
+            xhr.open(requestOptions.method, requestOptions.url, async);
+        }
+
+        if (options.withCredentials || this.withCredentials) {
+            xhr.withCredentials = true;
+        }
+
+        return xhr;
+    },
+
+    
+    getXhrInstance: (function() {
+        var options = [function() {
+            return new XMLHttpRequest();
+        }, function() {
+            return new ActiveXObject('MSXML2.XMLHTTP.3.0');
+        }, function() {
+            return new ActiveXObject('MSXML2.XMLHTTP');
+        }, function() {
+            return new ActiveXObject('Microsoft.XMLHTTP');
+        }], i = 0,
+            len = options.length,
+            xhr;
+
+        for (; i < len; ++i) {
+            try {
+                xhr = options[i];
+                xhr();
+                break;
+            } catch(e) {
+            }
+        }
+        return xhr;
+    }()),
+
+    
+    isLoading : function(request) {
+        if (!request) {
+            request = this.getLatest();
+        }
+        if (!(request && request.xhr)) {
+            return false;
+        }
+        
+        var state = request.xhr.readyState;
+        return !(state === 0 || state == 4);
+    },
+
+    
+    abort : function(request) {
+        var me = this,
+            xhr;
+        
+        if (!request) {
+            request = me.getLatest();
+        }
+
+        if (request && me.isLoading(request)) {
+            
+            xhr = request.xhr;
+            try {
+                xhr.onreadystatechange = null;
+            } catch (e) {
+                
+                
+                xhr = Ext.emptyFn;
+            }
+            xhr.abort();
+            me.clearTimeout(request);
+            if (!request.timedout) {
+                request.aborted = true;
+            }
+            me.onComplete(request);
+            me.cleanup(request);
+        }
+    },
+    
+    
+    abortAll: function(){
+        var requests = this.requests,
+            id;
+        
+        for (id in requests) {
+            if (requests.hasOwnProperty(id)) {
+                this.abort(requests[id]);
+            }
+        }
+    },
+    
+    
+    getLatest: function(){
+        var id = this.latestId,
+            request;
+            
+        if (id) {
+            request = this.requests[id];
+        }
+        return request || null;
+    },
+
+    
+    onStateChange : function(request) {
+        if (request.xhr.readyState == 4) {
+            this.clearTimeout(request);
+            this.onComplete(request);
+            this.cleanup(request);
+        }
+    },
+
+    
+    clearTimeout: function(request) {
+        clearTimeout(request.timeout);
+        delete request.timeout;
+    },
+
+    
+    cleanup: function(request) {
+        request.xhr = null;
+        delete request.xhr;
+    },
+
+    
+    onComplete : function(request) {
+        var me = this,
+            options = request.options,
+            result,
+            success,
+            response;
+
+        try {
+            result = me.parseStatus(request.xhr.status);
+        } catch (e) {
+            
+            result = {
+                success : false,
+                isException : false
+            };
+        }
+        success = result.success;
+
+        if (success) {
+            response = me.createResponse(request);
+            me.fireEvent('requestcomplete', me, response, options);
+            Ext.callback(options.success, options.scope, [response, options]);
+        } else {
+            if (result.isException || request.aborted || request.timedout) {
+                response = me.createException(request);
+            } else {
+                response = me.createResponse(request);
+            }
+            me.fireEvent('requestexception', me, response, options);
+            Ext.callback(options.failure, options.scope, [response, options]);
+        }
+        Ext.callback(options.callback, options.scope, [options, success, response]);
+        delete me.requests[request.id];
+        return response;
+    },
+
+    
+    parseStatus: function(status) {
+        
+        status = status == 1223 ? 204 : status;
+
+        var success = (status >= 200 && status < 300) || status == 304,
+            isException = false;
+
+        if (!success) {
+            switch (status) {
+                case 12002:
+                case 12029:
+                case 12030:
+                case 12031:
+                case 12152:
+                case 13030:
+                    isException = true;
+                    break;
+            }
+        }
+        return {
+            success: success,
+            isException: isException
+        };
+    },
+
+    
+    createResponse : function(request) {
+        var xhr = request.xhr,
+            headers = {},
+            lines = xhr.getAllResponseHeaders().replace(/\r\n/g, '\n').split('\n'),
+            count = lines.length,
+            line, index, key, value, response;
+
+        while (count--) {
+            line = lines[count];
+            index = line.indexOf(':');
+            if (index >= 0) {
+                key = line.substr(0, index).toLowerCase();
+                if (line.charAt(index + 1) == ' ') {
+                    ++index;
+                }
+                headers[key] = line.substr(index + 1);
+            }
+        }
+
+        request.xhr = null;
+        delete request.xhr;
+
+        response = {
+            request: request,
+            requestId : request.id,
+            status : xhr.status,
+            statusText : xhr.statusText,
+            getResponseHeader : function(header) {
+                return headers[header.toLowerCase()];
+            },
+            getAllResponseHeaders : function() {
+                return headers;
+            },
+            responseText : xhr.responseText,
+            responseXML : xhr.responseXML
+        };
+
+        
+        
+        xhr = null;
+        return response;
+    },
+
+    
+    createException : function(request) {
+        return {
+            request : request,
+            requestId : request.id,
+            status : request.aborted ? -1 : 0,
+            statusText : request.aborted ? 'transaction aborted' : 'communication failure',
+            aborted: request.aborted,
+            timedout: request.timedout
+        };
+    }
+});
+
+
+Ext.define('Ext.Ajax', {
+    extend: 'Ext.data.Connection',
+    singleton: true,
+
+    
+    
+    
+    
+    
+    
+
+    
+    
+    
+    
+    
+    
+
+    
+    autoAbort : false
+});
+
+
+Ext.define('Ext.util.Floating', {
+
+    uses: ['Ext.Layer', 'Ext.window.Window'],
+
+    
+    focusOnToFront: true,
+
+    
+    shadow: 'sides',
+
+    
+
+    constructor: function (dom) {
+        var me = this;
+
+        me.el = new Ext.Layer(Ext.apply({
+            hideMode     : me.hideMode,
+            hidden       : me.hidden,
+            shadow       : (typeof me.shadow != 'undefined') ? me.shadow : 'sides',
+            shadowOffset : me.shadowOffset,
+            constrain    : false,
+            shim         : (me.shim === false) ? false : undefined
+        }, me.floating), dom);
+
+        
+        me.floating = true;
+        
+        
+        
+        
+        me.registerWithOwnerCt();
+    },
+
+    registerWithOwnerCt: function() {
+        var me = this;
+
+        if (me.zIndexParent) {
+            me.zIndexParent.unregisterFloatingItem(me);
+        }
+
+        
+        me.zIndexParent = me.up('[floating]');
+        me.setFloatParent(me.ownerCt);
+        delete me.ownerCt;
+
+        if (me.zIndexParent) {
+            me.zIndexParent.registerFloatingItem(me);
+        } else {
+            Ext.WindowManager.register(me);
+        }
+    },
+
+    setFloatParent: function(floatParent) {
+        var me = this;
+
+        
+        if (me.floatParent) {
+            me.mun(me.floatParent, {
+                hide: me.onFloatParentHide,
+                show: me.onFloatParentShow,
+                scope: me
+            });
+        }
+
+        me.floatParent = floatParent;
+
+        
+        if (floatParent) {
+            me.mon(me.floatParent, {
+                hide: me.onFloatParentHide,
+                show: me.onFloatParentShow,
+                scope: me
+            });
+        }
+
+        
+        
+        if ((me.constrain || me.constrainHeader) && !me.constrainTo) {
+            me.constrainTo = floatParent ? floatParent.getTargetEl() : me.container;
+        }
+    },
+    
+    onAfterFloatLayout: function(){
+        this.syncShadow();   
+    },
+
+    onFloatParentHide: function() {
+        var me = this;
+
+        if (me.hideOnParentHide !== false && me.isVisible()) {
+            me.hide();
+            me.showOnParentShow = true;
+        }
+    },
+
+    onFloatParentShow: function() {
+        if (this.showOnParentShow) {
+            delete this.showOnParentShow;
+            this.show();
+        }
+    },
+
+    
+    
+    
+    
+    
+    setZIndex: function(index) {
+        var me = this;
+
+        me.el.setZIndex(index);
+
+        
+        index += 10;
+
+        
+        
+        if (me.floatingDescendants) {
+            index = Math.floor(me.floatingDescendants.setBase(index) / 100) * 100 + 10000;
+        }
+        return index;
+    },
+
+    
+    doConstrain: function(constrainTo) {
+        var me = this,
+
+            
+            
+            
+            vector = me.getConstrainVector(constrainTo),
+            xy;
+
+        if (vector) {
+            xy = me.getPosition(!!me.floatParent);
+            xy[0] += vector[0];
+            xy[1] += vector[1];
+            me.setPosition(xy);
+        }
+    },
+
+
+    
+    getConstrainVector: function(constrainTo){
+        var me = this;
+
+        if (me.constrain || me.constrainHeader) {
+            constrainTo = constrainTo || (me.floatParent && me.floatParent.getTargetEl()) || me.container || me.el.getScopeParent();
+            return (me.constrainHeader ? me.header.el : me.el).getConstrainVector(constrainTo);
+        }
+    },
+
+    
+    alignTo: function(element, position, offsets) {
+
+        
+        
+        this.setPagePosition(this.el.getAlignToXY(element.el || element, position, offsets));
+        return this;
+    },
+
+    
+    toFront: function(preventFocus) {
+        var me = this;
+
+        
+        
+        if (me.zIndexParent && me.bringParentToFront !== false) {
+            me.zIndexParent.toFront(true);
+        }
+        
+        if (!Ext.isDefined(preventFocus)) {
+            preventFocus = !me.focusOnToFront;
+        }
+        
+        if (preventFocus) {
+            me.preventFocusOnActivate = true;
+        }
+        if (me.zIndexManager.bringToFront(me)) {    
+            if (!preventFocus) {
+                
+                
+                
+                me.focus(false, true);
+            }
+        }
+        delete me.preventFocusOnActivate;
+        return me;
+    },
+
+    
+    setActive: function(active, newActive) {
+        var me = this;
+        
+        if (active) {
+            if (me.el.shadow && !me.maximized) {
+                me.el.enableShadow(true);
+            }
+            if (me.modal && !me.preventFocusOnActivate) {
+                me.focus(false, true);
+            }
+            me.fireEvent('activate', me);
+        } else {
+            
+            
+            if (me.isWindow && (newActive && newActive.isWindow)) {
+                me.el.disableShadow();
+            }
+            me.fireEvent('deactivate', me);
+        }
+    },
+
+    
+    toBack: function() {
+        this.zIndexManager.sendToBack(this);
+        return this;
+    },
+
+    
+    center: function() {
+        var me = this,
+            xy;
+            
+        if (me.isVisible()) {
+            xy = me.el.getAlignToXY(me.container, 'c-c');
+            me.setPagePosition(xy);
+        } else {
+            me.needsCenter = true;
+        }
+        return me;
+    },
+    
+    onFloatShow: function() {
+        if (this.needsCenter) {
+            this.center();    
+        }
+        delete this.needsCenter;
+    },
+
+    
+    syncShadow : function() {
+        if (this.floating) {
+            this.el.sync(true);
+        }
+    },
+
+    
+    fitContainer: function() {
+        var me = this,
+            parent = me.floatParent,
+            container = parent ? parent.getTargetEl() : me.container;
+
+        me.setSize(container.getViewSize(false));
+        me.setPosition.apply(me, parent ? [0, 0] : container.getXY());
+    }
+});
+
+
+Ext.define('Ext.Component', {
+
+    
+
+    alias: ['widget.component', 'widget.box'],
+
+    extend: 'Ext.AbstractComponent',
+
+    requires: [
+        'Ext.util.DelayedTask'
+    ],
+
+    uses: [
+        'Ext.Layer',
+        'Ext.resizer.Resizer',
+        'Ext.util.ComponentDragger'
+    ],
+
+    mixins: {
+        floating: 'Ext.util.Floating'
+    },
+
+    statics: {
+        
+        DIRECTION_TOP: 'top',
+        DIRECTION_RIGHT: 'right',
+        DIRECTION_BOTTOM: 'bottom',
+        DIRECTION_LEFT: 'left',
+
+        VERTICAL_DIRECTION_Re: /^(?:top|bottom)$/,
+
+        
+        
+        INVALID_ID_CHARS_Re: /[\.,\s]/g
+    },
+
+    
+
+    
+
+    
+    resizeHandles: 'all',
+
+    
+
+    
+
+    
+
+    
+    floating: false,
+
+    
+    toFrontOnShow: true,
+
+    
+
+    
+
+    
+
+    
+    
+    
+
+    
+
+    
+
+    hideMode: 'display',
+
+    bubbleEvents: [],
+
+    monPropRe: /^(?:scope|delay|buffer|single|stopEvent|preventDefault|stopPropagation|normalized|args|delegate)$/,
+
+    defaultComponentLayoutType: 'autocomponent',
+
+    
+    
+    
+    
+    
+    
+
+    
+    constructor: function(config) {
+        var me = this;
+
+        config = config || {};
+        if (config.initialConfig) {
+
+            
+            if (config.isAction) {
+                me.baseAction = config;
+            }
+            config = config.initialConfig;
+            
+        }
+        else if (config.tagName || config.dom || Ext.isString(config)) {
+            
+            config = {
+                applyTo: config,
+                id: config.id || config
+            };
+        }
+
+        me.callParent([config]);
+
+        
+        
+        if (me.baseAction){
+            me.baseAction.addComponent(me);
+        }
+    },
+
+    
+    initComponent: function() {
+        var me = this;
+
+        me.callParent();
+
+        if (me.listeners) {
+            me.on(me.listeners);
+            me.listeners = null; 
+        }
+        me.enableBubble(me.bubbleEvents);
+        me.mons = [];
+    },
+
+
+    
+    afterRender: function() {
+        var me = this;
+
+        me.callParent();
+
+        if (!(me.x && me.y) && (me.pageX || me.pageY)) {
+            me.setPagePosition(me.pageX, me.pageY);
+        }
+    },
+
+    
+    setAutoScroll : function(scroll) {
+        var me = this;
+
+        me.autoScroll = !!scroll;
+
+        
+        
+        
+        if (me.rendered) {
+            me.getTargetEl().setStyle(me.getOverflowStyle());
+        }
+        me.updateLayout();
+        return me;
+    },
+
+    
+    setOverflowXY: function(overflowX, overflowY) {
+        var me = this,
+            argCount = arguments.length;
+
+        if (argCount) {
+            me.overflowX = overflowX || '';
+            if (argCount > 1) {
+                me.overflowY = overflowY || '';
+            }
+        }
+
+        
+        
+        
+        if (me.rendered) {
+            me.getTargetEl().setStyle(me.getOverflowStyle());
+        }
+        me.updateLayout();
+        return me;
+    },
+
+    beforeRender: function () {
+        var me = this,
+            floating = me.floating,
+            cls;
+
+        if (floating) {
+            me.addCls(Ext.baseCSSPrefix + 'layer');
+
+            cls = floating.cls;
+            if (cls) {
+                me.addCls(cls);
+            }
+        }
+
+        return me.callParent();
+    },
+    
+    afterComponentLayout: function(){
+        this.callParent(arguments);
+        if (this.floating) {
+            this.onAfterFloatLayout();
+        }
+    },
+
+    
+    makeFloating : function (dom) {
+        this.mixins.floating.constructor.call(this, dom);
+    },
+
+    wrapPrimaryEl: function (dom) {
+        if (this.floating) {
+            this.makeFloating(dom);
+        } else {
+            this.callParent(arguments);
+        }
+    },
+
+    initResizable: function(resizable) {
+        var me = this;
+
+        resizable = Ext.apply({
+            target: me,
+            dynamic: false,
+            constrainTo: me.constrainTo || (me.floatParent ? me.floatParent.getTargetEl() : null),
+            handles: me.resizeHandles
+        }, resizable);
+        resizable.target = me;
+        me.resizer = new Ext.resizer.Resizer(resizable);
+    },
+
+    getDragEl: function() {
+        return this.el;
+    },
+
+    initDraggable: function() {
+        var me = this,
+
+            
+            
+            
+            dragTarget = (me.resizer && me.resizer.el !== me.el) ? me.resizerComponent = new Ext.Component({
+                el: me.resizer.el,
+                rendered: true,
+                container: me.container
+            }) : me,
+            ddConfig = Ext.applyIf({
+                el: dragTarget.getDragEl(),
+                constrainTo: me.constrain ? (me.constrainTo || (me.floatParent ? me.floatParent.getTargetEl() : me.el.getScopeParent())) : undefined
+            }, me.draggable);
+
+        
+        if (me.constrain || me.constrainDelegate) {
+            ddConfig.constrain = me.constrain;
+            ddConfig.constrainDelegate = me.constrainDelegate;
+        }
+
+        me.dd = new Ext.util.ComponentDragger(dragTarget, ddConfig);
+    },
+
+    
+    scrollBy: function(deltaX, deltaY, animate) {
+        var el;
+
+        if ((el = this.getTargetEl()) && el.dom) {
+            el.scrollBy.apply(el, arguments);
+        }
+    },
+
+    
+    setLoading : function(load, targetEl) {
+        var me = this,
+            config;
+
+        if (me.rendered) {
+            Ext.destroy(me.loadMask);
+            me.loadMask = null;
+
+            if (load !== false && !me.collapsed) {
+                if (Ext.isObject(load)) {
+                    config = Ext.apply({}, load);
+                } else if (Ext.isString(load)) {
+                    config = {msg: load};
+                } else {
+                    config = {};
+                }
+                if (targetEl) {
+                    Ext.applyIf(config, {
+                        useTargetEl: true
+                    });
+                }
+                me.loadMask = new Ext.LoadMask(me, config);
+                me.loadMask.show();
+            }
+        }
+        return me.loadMask;
+    },
+
+    beforeSetPosition: function () {
+        var me = this,
+            pos = me.callParent(arguments), 
+            adj;
+
+        if (pos) {
+            adj = me.adjustPosition(pos.x, pos.y);
+            pos.x = adj.x;
+            pos.y = adj.y;
+        }
+        return pos || null;
+    },
+
+    afterSetPosition: function(ax, ay) {
+        this.onPosition(ax, ay);
+        this.fireEvent('move', this, ax, ay);
+    },
+
+    
+    showAt: function(x, y, animate) {
+        var me = this;
+
+        if (!me.rendered && (me.autoRender || me.floating)) {
+            me.doAutoRender();
+            
+            me.hidden = true;
+        }
+        if (me.floating) {
+            me.setPosition(x, y, animate);
+        } else {
+            me.setPagePosition(x, y, animate);
+        }
+        me.show();
+    },
+
+    
+    setPagePosition: function(x, y, animate) {
+        var me = this,
+            p,
+            floatParentBox;
+
+        if (Ext.isArray(x)) {
+            y = x[1];
+            x = x[0];
+        }
+        me.pageX = x;
+        me.pageY = y;
+
+        if (me.floating) {
+
+            
+            if (me.isContainedFloater()) {
+                floatParentBox = me.floatParent.getTargetEl().getViewRegion();
+                if (Ext.isNumber(x) && Ext.isNumber(floatParentBox.left)) {
+                    x -= floatParentBox.left;
+                }
+                if (Ext.isNumber(y) && Ext.isNumber(floatParentBox.top)) {
+                    y -= floatParentBox.top;
+                }
+            } else {
+                p = me.el.translatePoints(x, y);
+                x = p.left;
+                y = p.top;
+            }
+
+            me.setPosition(x, y, animate);
+        } else {
+            p = me.el.translatePoints(x, y);
+            me.setPosition(p.left, p.top, animate);
+        }
+
+        return me;
+    },
+
+    
+    
+    isContainedFloater: function() {
+        return (this.floating && this.floatParent);
+    },
+
+    
+    getBox : function(local){
+        var pos = local ? this.getPosition(local) : this.el.getXY(),
+            size = this.getSize();
+
+        size.x = pos[0];
+        size.y = pos[1];
+        return size;
+    },
+
+    
+    updateBox : function(box){
+        this.setSize(box.width, box.height);
+        this.setPagePosition(box.x, box.y);
+        return this;
+    },
+
+    
+    getOuterSize: function() {
+        var el = this.el;
+        return {
+            width: el.getWidth() + el.getMargin('lr'),
+            height: el.getHeight() + el.getMargin('tb')
+        };
+    },
+
+    
+    adjustPosition: function(x, y) {
+        var me = this,
+            floatParentBox;
+
+        
+        if (me.isContainedFloater()) {
+            floatParentBox = me.floatParent.getTargetEl().getViewRegion();
+            x += floatParentBox.left;
+            y += floatParentBox.top;
+        }
+
+        return {
+            x: x,
+            y: y
+        };
+    },
+
+    
+    getPosition: function(local) {
+        var me = this,
+            el = me.el,
+            xy,
+            isContainedFloater = me.isContainedFloater(),
+            floatParentBox;
+
+        
+        if ((local === true) && !isContainedFloater) {
+            return [el.getLocalX(), el.getLocalY()];
+        }
+
+        xy = me.el.getXY();
+
+        
+        if ((local === true) && isContainedFloater) {
+            floatParentBox = me.floatParent.getTargetEl().getViewRegion();
+            xy[0] -= floatParentBox.left;
+            xy[1] -= floatParentBox.top;
+        }
+        return xy;
+    },
+
+    getId: function() {
+        var me = this,
+            xtype;
+
+        if (!me.id) {
+            xtype = me.getXType();
+            if (xtype) {
+                xtype = xtype.replace(Ext.Component.INVALID_ID_CHARS_Re, '-');
+            } else {
+                xtype = Ext.name.toLowerCase() + '-comp';
+            }
+            me.id = xtype + '-' + me.getAutoId();
+        }
+        return me.id;
+    },
+
+    
+    show: function(animateTarget, cb, scope) {
+        var me = this,
+            rendered = me.rendered;
+
+        if (rendered && me.isVisible()) {
+            if (me.toFrontOnShow && me.floating) {
+                me.toFront();
+            }
+        } else {
+            if (me.fireEvent('beforeshow', me) !== false) {
+                
+                me.hidden = false;
+                if (!rendered && (me.autoRender || me.floating)) {
+                    me.doAutoRender();
+                    rendered = me.rendered;
+                }
+            
+                if (rendered) {
+                    me.beforeShow();
+                    me.onShow.apply(me, arguments);
+                    me.afterShow.apply(me, arguments);
+                }
+            } else {
+                me.onShowVeto();
+            }
+        }
+        return me;
+    },
+    
+    onShowVeto: Ext.emptyFn,
+
+    
+    beforeShow: Ext.emptyFn,
+
+    
+    onShow: function() {
+        var me = this;
+
+        me.el.show();
+        me.callParent(arguments);
+
+        
+        if (me.floating) {
+            if (me.maximized) {
+                me.fitContainer();
+            }
+            else if (me.constrain) {
+                me.doConstrain();
+            }
+        }
+    },
+
+    
+    afterShow: function(animateTarget, cb, scope) {
+        var me = this,
+            fromBox,
+            toBox,
+            ghostPanel;
+
+        
+        animateTarget = animateTarget || me.animateTarget;
+
+        
+        if (!me.ghost) {
+            animateTarget = null;
+        }
+        
+        if (animateTarget) {
+            animateTarget = animateTarget.el ? animateTarget.el : Ext.get(animateTarget);
+            toBox = me.el.getBox();
+            fromBox = animateTarget.getBox();
+            me.el.addCls(Ext.baseCSSPrefix + 'hide-offsets');
+            ghostPanel = me.ghost();
+            ghostPanel.el.stopAnimation();
+
+            
+            ghostPanel.el.setX(-10000);
+
+            ghostPanel.el.animate({
+                from: fromBox,
+                to: toBox,
+                listeners: {
+                    afteranimate: function() {
+                        delete ghostPanel.componentLayout.lastComponentSize;
+                        me.unghost();
+                        me.el.removeCls(Ext.baseCSSPrefix + 'hide-offsets');
+                        me.onShowComplete(cb, scope);
+                    }
+                }
+            });
+        }
+        else {
+            me.onShowComplete(cb, scope);
+        }
+    },
+
+    
+    onShowComplete: function(cb, scope) {
+        var me = this;
+        if (me.floating) {
+            me.toFront();
+            me.onFloatShow();
+        }
+        Ext.callback(cb, scope || me);
+        me.fireEvent('show', me);
+        delete me.hiddenByLayout;
+    },
+
+    
+    hide: function() {
+        var me = this;
+
+        
+        
+        me.showOnParentShow = false;
+
+        if (!(me.rendered && !me.isVisible()) && me.fireEvent('beforehide', me) !== false) {
+            me.hidden = true;
+            if (me.rendered) {
+                me.onHide.apply(me, arguments);
+            }
+        }
+        return me;
+    },
+
+    
+    onHide: function(animateTarget, cb, scope) {
+        var me = this,
+            ghostPanel,
+            toBox;
+
+        
+        animateTarget = animateTarget || me.animateTarget;
+
+        
+        if (!me.ghost) {
+            animateTarget = null;
+        }
+        
+        if (animateTarget) {
+            animateTarget = animateTarget.el ? animateTarget.el : Ext.get(animateTarget);
+            ghostPanel = me.ghost();
+            ghostPanel.el.stopAnimation();
+            toBox = animateTarget.getBox();
+            toBox.width += 'px';
+            toBox.height += 'px';
+            ghostPanel.el.animate({
+                to: toBox,
+                listeners: {
+                    afteranimate: function() {
+                        delete ghostPanel.componentLayout.lastComponentSize;
+                        ghostPanel.el.hide();
+                        me.afterHide(cb, scope);
+                    }
+                }
+            });
+        }
+        me.el.hide();
+        if (!animateTarget) {
+            me.afterHide(cb, scope);
+        }
+    },
+
+    
+    afterHide: function(cb, scope) {
+        var me = this;
+        delete me.hiddenByLayout;
+
+        
+        
+        Ext.AbstractComponent.prototype.onHide.call(this);
+
+        Ext.callback(cb, scope || me);
+        me.fireEvent('hide', me);
+    },
+
+    
+    onDestroy: function() {
+        var me = this;
+
+        
+        if (me.rendered) {
+            Ext.destroy(
+                me.proxy,
+                me.proxyWrap,
+                me.resizer,
+                me.resizerComponent
+            );
+        }
+        delete me.focusTask;
+        me.callParent();
+    },
+
+    deleteMembers: function() {
+        var args = arguments,
+            len = args.length,
+            i = 0;
+        for (; i < len; ++i) {
+            delete this[args[i]];
+        }
+    },
+
+    
+    focus: function(selectText, delay) {
+        var me = this,
+            focusEl,
+            focusElDom,
+            containerScrollTop;
+
+        
+        if (delay) {
+            if (!me.focusTask) {
+                me.focusTask = new Ext.util.DelayedTask(me.focus);
+            }
+            me.focusTask.delay(Ext.isNumber(delay) ? delay : 10, null, me, [selectText, false]);
+            return me;
+        }
+
+        if (me.rendered && !me.isDestroyed && me.isVisible(true) && (focusEl = me.getFocusEl())) {
+
+            
+            
+            if (focusEl.isComponent) {
+                return focusEl.focus(selectText, delay);
+            }
+
+            
+            if ((focusElDom = focusEl.dom)) {
+
+                
+                if (focusEl.needsTabIndex()) {
+                    focusElDom.tabIndex = -1;
+                }
+
+                if (me.floating) {
+                    containerScrollTop = me.container.dom.scrollTop;
+                }
+
+                
+                
+                
+                focusEl.focus();
+                if (selectText === true) {
+                    focusElDom.select();
+                }
+            }
+
+            
+            
+            if (me.floating) {
+                me.toFront(true);
+                if (containerScrollTop !== undefined) {
+                    me.container.dom.scrollTop = containerScrollTop;
+                }
+            }
+        }
+        return me;
+    },
+
+    
+    cancelFocus: function() {
+        var task = this.focusTask;
+        if (task) {
+            task.cancel();
+        }
+    },
+
+    
+    blur: function() {
+        var focusEl;
+        if (this.rendered && (focusEl = this.getFocusEl())) {
+            focusEl.blur();
+        }
+        return this;
+    },
+
+    getEl: function() {
+        return this.el;
+    },
+
+    
+    getResizeEl: function() {
+        return this.el;
+    },
+
+    
+    getPositionEl: function() {
+        return this.el;
+    },
+
+    
+    getActionEl: function() {
+        return this.el;
+    },
+
+    
+    getVisibilityEl: function() {
+        return this.el;
+    },
+
+    
+    onResize: Ext.emptyFn,
+
+    
+    
+    
+    
+    
+    getBubbleTarget: function() {
+        return this.ownerCt || this.floatParent;
+    },
+
+    
+    getContentTarget: function() {
+        return this.el;
+    },
+
+    
+    cloneConfig: function(overrides) {
+        overrides = overrides || {};
+        var id = overrides.id || Ext.id(),
+            cfg = Ext.applyIf(overrides, this.initialConfig),
+            self;
+
+        cfg.id = id;
+
+        self = Ext.getClass(this);
+
+        
+        return new self(cfg);
+    },
+
+    
+    getXType: function() {
+        return this.self.xtype;
+    },
+
+    
+    findParentBy: function(fn) {
+        var p;
+
+        
+        for (p = this.getBubbleTarget(); p && !fn(p, this); p = p.getBubbleTarget()) {
+            
+        }
+        return p || null;
+    },
+
+    
+    findParentByType: function(xtype) {
+        return Ext.isFunction(xtype) ?
+            this.findParentBy(function(p) {
+                return p.constructor === xtype;
+            })
+        :
+            this.up(xtype);
+    },
+
+    
+    bubble: function(fn, scope, args) {
+        var p = this;
+        while (p) {
+            if (fn.apply(scope || p, args || [p]) === false) {
+                break;
+            }
+            p = p.getBubbleTarget();
+        }
+        return this;
+    },
+
+    getProxy: function() {
+        var me = this,
+            target;
+
+        if (!me.proxy) {
+            target = Ext.getBody();
+            if (Ext.scopeResetCSS) {
+                me.proxyWrap = target = Ext.getBody().createChild({
+                    cls: Ext.resetCls
+                });
+            }
+            me.proxy = me.el.createProxy(Ext.baseCSSPrefix + 'proxy-el', target, true);
+        }
+        return me.proxy;
+    }
+});
+
+
+Ext.define('Ext.ElementLoader', {
+
+    
+
+    mixins: {
+        observable: 'Ext.util.Observable'
+    },
+
+    uses: [
+        'Ext.data.Connection',
+        'Ext.Ajax'
+    ],
+
+    statics: {
+        Renderer: {
+            Html: function(loader, response, active){
+                loader.getTarget().update(response.responseText, active.scripts === true);
+                return true;
+            }
+        }
+    },
+
+    
+
+    
+    url: null,
+
+    
+    params: null,
+
+    
+    baseParams: null,
+
+    
+    autoLoad: false,
+
+    
+    target: null,
+
+    
+    loadMask: false,
+
+    
+    ajaxOptions: null,
+
+    
+    scripts: false,
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+    isLoader: true,
+
+    constructor: function(config) {
+        var me = this,
+            autoLoad;
+
+        config = config || {};
+        Ext.apply(me, config);
+        me.setTarget(me.target);
+        me.addEvents(
+            
+            'beforeload',
+
+            
+            'exception',
+
+            
+            'load'
+        );
+
+        
+        me.mixins.observable.constructor.call(me);
+
+        if (me.autoLoad) {
+            autoLoad = me.autoLoad;
+            if (autoLoad === true) {
+                autoLoad = {};
+            }
+            me.load(autoLoad);
+        }
+    },
+
+    
+    setTarget: function(target){
+        var me = this;
+        target = Ext.get(target);
+        if (me.target && me.target != target) {
+            me.abort();
+        }
+        me.target = target;
+    },
+
+    
+    getTarget: function(){
+        return this.target || null;
+    },
+
+    
+    abort: function(){
+        var active = this.active;
+        if (active !== undefined) {
+            Ext.Ajax.abort(active.request);
+            if (active.mask) {
+                this.removeMask();
+            }
+            delete this.active;
+        }
+    },
+
+    
+    removeMask: function(){
+        this.target.unmask();
+    },
+
+    
+    addMask: function(mask){
+        this.target.mask(mask === true ? null : mask);
+    },
+
+    
+    load: function(options) {
+
+        options = Ext.apply({}, options);
+
+        var me = this,
+            target = me.target,
+            mask = Ext.isDefined(options.loadMask) ? options.loadMask : me.loadMask,
+            params = Ext.apply({}, options.params),
+            ajaxOptions = Ext.apply({}, options.ajaxOptions),
+            callback = options.callback || me.callback,
+            scope = options.scope || me.scope || me,
+            request;
+
+        Ext.applyIf(ajaxOptions, me.ajaxOptions);
+        Ext.applyIf(options, ajaxOptions);
+
+        Ext.applyIf(params, me.params);
+        Ext.apply(params, me.baseParams);
+
+        Ext.applyIf(options, {
+            url: me.url
+        });
+
+
+        Ext.apply(options, {
+            scope: me,
+            params: params,
+            callback: me.onComplete
+        });
+
+        if (me.fireEvent('beforeload', me, options) === false) {
+            return;
+        }
+
+        if (mask) {
+            me.addMask(mask);
+        }
+
+        request = Ext.Ajax.request(options);
+        me.active = {
+            request: request,
+            options: options,
+            mask: mask,
+            scope: scope,
+            callback: callback,
+            success: options.success || me.success,
+            failure: options.failure || me.failure,
+            renderer: options.renderer || me.renderer,
+            scripts: Ext.isDefined(options.scripts) ? options.scripts : me.scripts
+        };
+        me.setOptions(me.active, options);
+    },
+
+    
+    setOptions: Ext.emptyFn,
+
+    
+    onComplete: function(options, success, response) {
+        var me = this,
+            active = me.active,
+            scope = active.scope,
+            renderer = me.getRenderer(active.renderer);
+
+
+        if (success) {
+            success = renderer.call(me, me, response, active) !== false;
+        }
+
+        if (success) {
+            Ext.callback(active.success, scope, [me, response, options]);
+            me.fireEvent('load', me, response, options);
+        } else {
+            Ext.callback(active.failure, scope, [me, response, options]);
+            me.fireEvent('exception', me, response, options);
+        }
+        Ext.callback(active.callback, scope, [me, success, response, options]);
+
+        if (active.mask) {
+            me.removeMask();
+        }
+
+        delete me.active;
+    },
+
+    
+    getRenderer: function(renderer){
+        if (Ext.isFunction(renderer)) {
+            return renderer;
+        }
+        return this.statics().Renderer.Html;
+    },
+
+    
+    startAutoRefresh: function(interval, options){
+        var me = this;
+        me.stopAutoRefresh();
+        me.autoRefresh = setInterval(function(){
+            me.load(options);
+        }, interval);
+    },
+
+    
+    stopAutoRefresh: function(){
+        clearInterval(this.autoRefresh);
+        delete this.autoRefresh;
+    },
+
+    
+    isAutoRefreshing: function(){
+        return Ext.isDefined(this.autoRefresh);
+    },
+
+    
+    destroy: function(){
+        var me = this;
+        me.stopAutoRefresh();
+        delete me.target;
+        me.abort();
+        me.clearListeners();
+    }
+});
+
+
+Ext.define('Ext.ComponentLoader', {
+
+    
+
+    extend: 'Ext.ElementLoader',
+
+    statics: {
+        Renderer: {
+            Data: function(loader, response, active){
+                var success = true;
+                try {
+                    loader.getTarget().update(Ext.decode(response.responseText));
+                } catch (e) {
+                    success = false;
+                }
+                return success;
+            },
+
+            Component: function(loader, response, active){
+                var success = true,
+                    target = loader.getTarget(),
+                    items = [];
+
+
+                try {
+                    items = Ext.decode(response.responseText);
+                } catch (e) {
+                    success = false;
+                }
+
+                if (success) {
+                    target.suspendLayouts();
+                    if (active.removeAll) {
+                        target.removeAll();
+                    }
+                    target.add(items);
+                    target.resumeLayouts(true);
+                }
+                return success;
+            }
+        }
+    },
+
+    
+
+    
+    target: null,
+
+    
+    loadMask: false,
+
+    
+
+    
+    renderer: 'html',
+
+    
+    setTarget: function(target){
+        var me = this;
+
+        if (Ext.isString(target)) {
+            target = Ext.getCmp(target);
+        }
+
+        if (me.target && me.target != target) {
+            me.abort();
+        }
+        me.target = target;
+    },
+
+    
+    removeMask: function(){
+        this.target.setLoading(false);
+    },
+
+    
+    addMask: function(mask){
+        this.target.setLoading(mask);
+    },
+
+
+    setOptions: function(active, options){
+        active.removeAll = Ext.isDefined(options.removeAll) ? options.removeAll : this.removeAll;
+    },
+
+    
+    getRenderer: function(renderer){
+        if (Ext.isFunction(renderer)) {
+            return renderer;
+        }
+
+        var renderers = this.statics().Renderer;
+        switch (renderer) {
+            case 'component':
+                return renderers.Component;
+            case 'data':
+                return renderers.Data;
+            default:
+                return Ext.ElementLoader.Renderer.Html;
+        }
+    }
+});
+
+
+Ext.define('Ext.Template', {
+
+    
+
+    requires: ['Ext.dom.Helper', 'Ext.util.Format'],
+
+    inheritableStatics: {
+        
+        from: function(el, config) {
+            el = Ext.getDom(el);
+            return new this(el.value || el.innerHTML, config || '');
+        }
+    },
+
+    
+
+    
+    constructor: function(html) {
+        var me = this,
+            args = arguments,
+            buffer = [],
+            i = 0,
+            length = args.length,
+            value;
+
+        me.initialConfig = {};
+        
+        
+        
+        
+        if (length === 1 && Ext.isArray(html)) {
+            args = html;
+            length = args.length;
+        }
+
+        if (length > 1) {
+            for (; i < length; i++) {
+                value = args[i];
+                if (typeof value == 'object') {
+                    Ext.apply(me.initialConfig, value);
+                    Ext.apply(me, value);
+                } else {
+                    buffer.push(value);
+                }
+            }
+        } else {
+            buffer.push(html);
+        }
+
+        
+        me.html = buffer.join('');
+
+        if (me.compiled) {
+            me.compile();
+        }
+    },
+
+    
+    isTemplate: true,
+
+    
+
+    
+    disableFormats: false,
+
+    re: /\{([\w\-]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?\}/g,
+
+    
+    apply: function(values) {
+        var me = this,
+            useFormat = me.disableFormats !== true,
+            fm = Ext.util.Format,
+            tpl = me,
+            ret;
+
+        if (me.compiled) {
+            return me.compiled(values).join('');
+        }
+
+        function fn(m, name, format, args) {
+            if (format && useFormat) {
+                if (args) {
+                    args = [values[name]].concat(Ext.functionFactory('return ['+ args +'];')());
+                } else {
+                    args = [values[name]];
+                }
+                if (format.substr(0, 5) == "this.") {
+                    return tpl[format.substr(5)].apply(tpl, args);
+                }
+                else {
+                    return fm[format].apply(fm, args);
+                }
+            }
+            else {
+                return values[name] !== undefined ? values[name] : "";
+            }
+        }
+
+        ret = me.html.replace(me.re, fn);
+        return ret;
+    },
+
+    
+    applyOut: function(values, out) {
+        var me = this;
+
+        if (me.compiled) {
+            out.push.apply(out, me.compiled(values));
+        } else {
+            out.push(me.apply(values));
+        }
+
+        return out;
+    },
+
+    
+    applyTemplate: function () {
+        return this.apply.apply(this, arguments);
+    },
+
+    
+    set: function(html, compile) {
+        var me = this;
+        me.html = html;
+        me.compiled = null;
+        return compile ? me.compile() : me;
+    },
+
+    compileARe: /\\/g,
+    compileBRe: /(\r\n|\n)/g,
+    compileCRe: /'/g,
+
+    /**
+     * Compiles the template into an internal function, eliminating the RegEx overhead.
+     * @return {Ext.Template} this
+     */
+    compile: function() {
+        var me = this,
+            fm = Ext.util.Format,
+            useFormat = me.disableFormats !== true,
+            body, bodyReturn;
+
+        function fn(m, name, format, args) {
+            if (format && useFormat) {
+                args = args ? ',' + args: "";
+                if (format.substr(0, 5) != "this.") {
+                    format = "fm." + format + '(';
+                }
+                else {
+                    format = 'this.' + format.substr(5) + '(';
+                }
+            }
+            else {
+                args = '';
+                format = "(values['" + name + "'] == undefined ? '' : ";
+            }
+            return "'," + format + "values['" + name + "']" + args + ") ,'";
+        }
+
+        bodyReturn = me.html.replace(me.compileARe, '\\\\').replace(me.compileBRe, '\\n').replace(me.compileCRe, "\\'").replace(me.re, fn);
+        body = "this.compiled = function(values){ return ['" + bodyReturn + "'];};";
+        eval(body);
+        return me;
+    },
+
+    /**
+     * Applies the supplied values to the template and inserts the new node(s) as the first child of el.
+     *
+     * @param {String/HTMLElement/Ext.Element} el The context element
+     * @param {Object/Array} values The template values. See {@link #applyTemplate} for details.
+     * @param {Boolean} returnElement (optional) true to return a Ext.Element.
+     * @return {HTMLElement/Ext.Element} The new node or Element
+     */
+    insertFirst: function(el, values, returnElement) {
+        return this.doInsert('afterBegin', el, values, returnElement);
+    },
+
+    /**
+     * Applies the supplied values to the template and inserts the new node(s) before el.
+     *
+     * @param {String/HTMLElement/Ext.Element} el The context element
+     * @param {Object/Array} values The template values. See {@link #applyTemplate} for details.
+     * @param {Boolean} returnElement (optional) true to return a Ext.Element.
+     * @return {HTMLElement/Ext.Element} The new node or Element
+     */
+    insertBefore: function(el, values, returnElement) {
+        return this.doInsert('beforeBegin', el, values, returnElement);
+    },
+
+    /**
+     * Applies the supplied values to the template and inserts the new node(s) after el.
+     *
+     * @param {String/HTMLElement/Ext.Element} el The context element
+     * @param {Object/Array} values The template values. See {@link #applyTemplate} for details.
+     * @param {Boolean} returnElement (optional) true to return a Ext.Element.
+     * @return {HTMLElement/Ext.Element} The new node or Element
+     */
+    insertAfter: function(el, values, returnElement) {
+        return this.doInsert('afterEnd', el, values, returnElement);
+    },
+
+    /**
+     * Applies the supplied `values` to the template and appends the new node(s) to the specified `el`.
+     *
+     * For example usage see {@link Ext.Template Ext.Template class docs}.
+     *
+     * @param {String/HTMLElement/Ext.Element} el The context element
+     * @param {Object/Array} values The template values. See {@link #applyTemplate} for details.
+     * @param {Boolean} returnElement (optional) true to return an Ext.Element.
+     * @return {HTMLElement/Ext.Element} The new node or Element
+     */
+    append: function(el, values, returnElement) {
+        return this.doInsert('beforeEnd', el, values, returnElement);
+    },
+
+    doInsert: function(where, el, values, returnElement) {
+        var newNode = Ext.DomHelper.insertHtml(where, Ext.getDom(el), this.apply(values));
+        return returnElement ? Ext.get(newNode) : newNode;
+    },
+
+    /**
+     * Applies the supplied values to the template and overwrites the content of el with the new node(s).
+     *
+     * @param {String/HTMLElement/Ext.Element} el The context element
+     * @param {Object/Array} values The template values. See {@link #applyTemplate} for details.
+     * @param {Boolean} returnElement (optional) true to return a Ext.Element.
+     * @return {HTMLElement/Ext.Element} The new node or Element
+     */
+    overwrite: function(el, values, returnElement) {
+        var newNode = Ext.DomHelper.overwrite(Ext.getDom(el), this.apply(values));
+        return returnElement ? Ext.get(newNode) : newNode;
+    }
+});
+
+/**
+ * This class parses the XTemplate syntax and calls abstract methods to process the parts.
+ * @private
+ */
+Ext.define('Ext.XTemplateParser', {
+    constructor: function (config) {
+        Ext.apply(this, config);
+    },
+
+    /**
+     * @property {Number} level The 'for' loop context level. This is adjusted up by one
+     * prior to calling {@link #doFor} and down by one after calling the corresponding
+     * {@link #doEnd} that closes the loop. This will be 1 on the first {@link #doFor}
+     * call.
+     */
+
+    /**
+     * This method is called to process a piece of raw text from the tpl.
+     * @param {String} text
+     * @method doText
+     */
+    // doText: function (text)
+
+    /**
+     * This method is called to process expressions (like `{[expr]}`).
+     * @param {String} expr The body of the expression (inside "{[" and "]}").
+     * @method doExpr
+     */
+    // doExpr: function (expr)
+
+    /**
+     * This method is called to process simple tags (like `{tag}`).
+     * @method doTag
+     */
+    // doTag: function (tag)
+
+    /**
+     * This method is called to process `<tpl else>`.
+     * @method doElse
+     */
+    // doElse: function ()
+
+    /**
+     * This method is called to process `{% text %}`.
+     * @param {String} text
+     * @method doEval
+     */
+    // doEval: function (text)
+
+    /**
+     * This method is called to process `<tpl if="action">`. If there are other attributes,
+     * these are passed in the actions object.
+     * @param {String} action
+     * @param {Object} actions Other actions keyed by the attribute name (such as 'exec').
+     * @method doIf
+     */
+    // doIf: function (action, actions)
+
+    /**
+     * This method is called to process `<tpl elseif="action">`. If there are other attributes,
+     * these are passed in the actions object.
+     * @param {String} action
+     * @param {Object} actions Other actions keyed by the attribute name (such as 'exec').
+     * @method doElseIf
+     */
+    // doElseIf: function (action, actions)
+
+    /**
+     * This method is called to process `<tpl switch="action">`. If there are other attributes,
+     * these are passed in the actions object.
+     * @param {String} action
+     * @param {Object} actions Other actions keyed by the attribute name (such as 'exec').
+     * @method doSwitch
+     */
+    // doSwitch: function (action, actions)
+
+    /**
+     * This method is called to process `<tpl case="action">`. If there are other attributes,
+     * these are passed in the actions object.
+     * @param {String} action
+     * @param {Object} actions Other actions keyed by the attribute name (such as 'exec').
+     * @method doCase
+     */
+    // doCase: function (action, actions)
+
+    /**
+     * This method is called to process `<tpl default>`.
+     * @method doDefault
+     */
+    // doDefault: function ()
+
+    /**
+     * This method is called to process `</tpl>`. It is given the action type that started
+     * the tpl and the set of additional actions.
+     * @param {String} type The type of action that is being ended.
+     * @param {Object} actions The other actions keyed by the attribute name (such as 'exec').
+     * @method doEnd
+     */
+    // doEnd: function (type, actions) 
+
+    /**
+     * This method is called to process `<tpl for="action">`. If there are other attributes,
+     * these are passed in the actions object.
+     * @param {String} action
+     * @param {Object} actions Other actions keyed by the attribute name (such as 'exec').
+     * @method doFor
+     */
+    // doFor: function (action, actions)
+
+    /**
+     * This method is called to process `<tpl exec="action">`. If there are other attributes,
+     * these are passed in the actions object.
+     * @param {String} action
+     * @param {Object} actions Other actions keyed by the attribute name.
+     * @method doExec
+     */
+    // doExec: function (action, actions)
+
+    /**
+     * This method is called to process an empty `<tpl>`. This is unlikely to need to be
+     * implemented, so a default (do nothing) version is provided.
+     * @method
+     */
+    doTpl: Ext.emptyFn,
+
+    parse: function (str) {
+        var me = this,
+            len = str.length,
+            aliases = { elseif: 'elif' },
+            topRe = me.topRe,
+            actionsRe = me.actionsRe,
+            index, stack, s, m, t, prev, frame, subMatch, begin, end, actions,
+            prop;
+
+        me.level = 0;
+        me.stack = stack = [];
+
+        for (index = 0; index < len; index = end) {
+            topRe.lastIndex = index;
+            m = topRe.exec(str);
+
+            if (!m) {
+                me.doText(str.substring(index, len));
+                break;
+            }
+
+            begin = m.index;
+            end = topRe.lastIndex;
+
+            if (index < begin) {
+                me.doText(str.substring(index, begin));
+            }
+
+            if (m[1]) {
+                end = str.indexOf('%}', begin+2);
+                me.doEval(str.substring(begin+2, end));
+                end += 2;
+            } else if (m[2]) {
+                end = str.indexOf(']}', begin+2);
+                me.doExpr(str.substring(begin+2, end));
+                end += 2;
+            } else if (m[3]) { // if ('{' token)
+                me.doTag(m[3]);
+            } else if (m[4]) { // content of a <tpl xxxxxx xxx> tag
+                actions = null;
+                while ((subMatch = actionsRe.exec(m[4])) !== null) {
+                    s = subMatch[2] || subMatch[3];
+                    if (s) {
+                        s = Ext.String.htmlDecode(s); // decode attr value
+                        t = subMatch[1];
+                        t = aliases[t] || t;
+                        actions = actions || {};
+                        prev = actions[t];
+
+                        if (typeof prev == 'string') {
+                            actions[t] = [prev, s];
+                        } else if (prev) {
+                            actions[t].push(s);
+                        } else {
+                            actions[t] = s;
+                        }
+                    }
+                }
+
+                if (!actions) {
+                    if (me.elseRe.test(m[4])) {
+                        me.doElse();
+                    } else if (me.defaultRe.test(m[4])) {
+                        me.doDefault();
+                    } else {
+                        me.doTpl();
+                        stack.push({ type: 'tpl' });
+                    }
+                }
+                else if (actions['if']) {
+                    me.doIf(actions['if'], actions);
+                    stack.push({ type: 'if' });
+                }
+                else if (actions['switch']) {
+                    me.doSwitch(actions['switch'], actions);
+                    stack.push({ type: 'switch' });
+                }
+                else if (actions['case']) {
+                    me.doCase(actions['case'], actions);
+                }
+                else if (actions['elif']) {
+                    me.doElseIf(actions['elif'], actions);
+                }
+                else if (actions['for']) {
+                    ++me.level;
+
+                    // Extract property name to use from indexed item
+                    if (prop = me.propRe.exec(m[4])) {
+                        actions.propName = prop[1] || prop[2];
+                    }
+                    me.doFor(actions['for'], actions);
+                    stack.push({ type: 'for', actions: actions });
+                }
+                else if (actions.exec) {
+                    me.doExec(actions.exec, actions);
+                    stack.push({ type: 'exec', actions: actions });
+                }
+                /*
+                else {
+                    // todo - error
+                }
+                */
+            } else if (m[0].length === 5) {
+                // if the length of m[0] is 5, assume that we're dealing with an opening tpl tag with no attributes (e.g. <tpl>...</tpl>)
+                // in this case no action is needed other than pushing it on to the stack
+                stack.push({ type: 'tpl' });
+            } else {
+                frame = stack.pop();
+                me.doEnd(frame.type, frame.actions);
+                if (frame.type == 'for') {
+                    --me.level;
+                }
+            }
+        }
+    },
+
+    // Internal regexes
+    
+    topRe:     /(?:(\{\%)|(\{\[)|\{([^{}]*)\})|(?:<tpl([^>]*)\>)|(?:<\/tpl>)/g,
+    actionsRe: /\s*(elif|elseif|if|for|exec|switch|case|eval)\s*\=\s*(?:(?:"([^"]*)")|(?:'([^']*)'))\s*/g,
+    propRe:    /prop=(?:(?:"([^"]*)")|(?:'([^']*)'))/,
+    defaultRe: /^\s*default\s*$/,
+    elseRe:    /^\s*else\s*$/
+});
+
+
+Ext.define('Ext.XTemplateCompiler', {
+    extend: 'Ext.XTemplateParser',
+
+    
+    
+    
+    useEval: Ext.isGecko,
+
+    
+    
+    
+    useIndex: Ext.isIE6 || Ext.isIE7,
+
+    useFormat: true,
+    
+    propNameRe: /^[\w\d\$]*$/,
+
+    compile: function (tpl) {
+        var me = this,
+            code = me.generate(tpl);
+
+        
+        
+        
+        
+        return me.useEval ? me.evalTpl(code) : (new Function('Ext', code))(Ext);
+    },
+
+    generate: function (tpl) {
+        var me = this,
+            
+            definitions = 'var fm=Ext.util.Format,ts=Object.prototype.toString;',
+            code;
+
+        
+        me.maxLevel = 0;
+
+        me.body = [
+            'var c0=values, a0=' + me.createArrayTest(0) + ', p0=parent, n0=xcount, i0=xindex, v;\n'
+        ];
+        if (me.definitions) {
+            if (typeof me.definitions === 'string') {
+                me.definitions = [me.definitions, definitions ];
+            } else {
+                me.definitions.push(definitions);
+            }
+        } else {
+            me.definitions = [ definitions ];
+        }
+        me.switches = [];
+
+        me.parse(tpl);
+
+        me.definitions.push(
+            (me.useEval ? '$=' : 'return') + ' function (' + me.fnArgs + ') {',
+                me.body.join(''),
+            '}'
+        );
+
+        code = me.definitions.join('\n');
+
+        
+        me.definitions.length = me.body.length = me.switches.length = 0;
+        delete me.definitions;
+        delete me.body;
+        delete me.switches;
+
+        return code;
+    },
+
+    
+    
+
+    doText: function (text) {
+        var me = this,
+            out = me.body;
+
+        text = text.replace(me.aposRe, "\\'").replace(me.newLineRe, '\\n');
+        if (me.useIndex) {
+            out.push('out[out.length]=\'', text, '\'\n');
+        } else {
+            out.push('out.push(\'', text, '\')\n');
+        }
+    },
+
+    doExpr: function (expr) {
+        var out = this.body;
+        out.push('if ((v=' + expr + ')!==undefined) out');
+
+        
+        
+        if (this.useIndex) {
+             out.push('[out.length]=v+\'\'\n');
+        } else {
+             out.push('.push(v+\'\')\n');
+        }
+    },
+
+    doTag: function (tag) {
+        this.doExpr(this.parseTag(tag));
+    },
+
+    doElse: function () {
+        this.body.push('} else {\n');
+    },
+
+    doEval: function (text) {
+        this.body.push(text, '\n');
+    },
+
+    doIf: function (action, actions) {
+        var me = this;
+
+        
+        if (action === '.') {
+            me.body.push('if (values) {\n');
+        } else if (me.propNameRe.test(action)) {
+            me.body.push('if (', me.parseTag(action), ') {\n');
+        }
+        
+        else {
+            me.body.push('if (', me.addFn(action), me.callFn, ') {\n');
+        }
+        if (actions.exec) {
+            me.doExec(actions.exec);
+        }
+    },
+
+    doElseIf: function (action, actions) {
+        var me = this;
+
+        
+        if (action === '.') {
+            me.body.push('else if (values) {\n');
+        } else if (me.propNameRe.test(action)) {
+            me.body.push('} else if (', me.parseTag(action), ') {\n');
+        }
+        
+        else {
+            me.body.push('} else if (', me.addFn(action), me.callFn, ') {\n');
+        }
+        if (actions.exec) {
+            me.doExec(actions.exec);
+        }
+    },
+
+    doSwitch: function (action) {
+        var me = this;
+
+        
+        if (action === '.') {
+            me.body.push('switch (values) {\n');
+        } else if (me.propNameRe.test(action)) {
+            me.body.push('switch (', me.parseTag(action), ') {\n');
+        }
+        
+        else {
+            me.body.push('switch (', me.addFn(action), me.callFn, ') {\n');
+        }
+        me.switches.push(0);
+    },
+
+    doCase: function (action) {
+        var me = this,
+            cases = Ext.isArray(action) ? action : [action],
+            n = me.switches.length - 1,
+            match, i;
+
+        if (me.switches[n]) {
+            me.body.push('break;\n');
+        } else {
+            me.switches[n]++;
+        }
+
+        for (i = 0, n = cases.length; i < n; ++i) {
+            match = me.intRe.exec(cases[i]);
+            cases[i] = match ? match[1] : ("'" + cases[i].replace(me.aposRe,"\\'") + "'");
+        }
+
+        me.body.push('case ', cases.join(': case '), ':\n');
+    },
+
+    doDefault: function () {
+        var me = this,
+            n = me.switches.length - 1;
+
+        if (me.switches[n]) {
+            me.body.push('break;\n');
+        } else {
+            me.switches[n]++;
+        }
+
+        me.body.push('default:\n');
+    },
+
+    doEnd: function (type, actions) {
+        var me = this,
+            L = me.level-1;
+
+        if (type == 'for') {
+            
+            if (actions.exec) {
+                me.doExec(actions.exec);
+            }
+
+            me.body.push('}\n');
+            me.body.push('parent=p',L,';values=r',L+1,';xcount=n',L,';xindex=i',L,'\n');
+        } else if (type == 'if' || type == 'switch') {
+            me.body.push('}\n');
+        }
+    },
+
+    doFor: function (action, actions) {
+        var me = this,
+            s,
+            L = me.level,
+            up = L-1,
+            pL = 'p' + L,
+            parentAssignment;
+
+        
+        if (action === '.') {
+            s = 'values';
+        } else if (me.propNameRe.test(action)) {
+            s = me.parseTag(action);
+        }
+        
+        else {
+            s = me.addFn(action) + me.callFn;
+        }
+
+        
+
+        
+        if (me.maxLevel < L) {
+            me.maxLevel = L;
+            me.body.push('var ');
+        }
+        
+        if (action == '.') {
+            parentAssignment = 'c' + L;
+        } else {
+            parentAssignment = 'a' + up + '?c' + up + '[i' + up + ']:p' + L;
+        }
+        
+        me.body.push('i',L,'=0,n', L, '=0,c',L,'=',s,',a',L,'=', me.createArrayTest(L), ',p',L,'=c',up,',r',L,'=values;\n',
+            'parent=',parentAssignment,'\n',
+            'if (c',L,'){if(a',L,'){n', L,'=c', L, '.length;}else if (c', L, '.isMixedCollection){c',L,'=c',L,'.items;n',L,'=c',L,'.length;}else if(c',L,'.isStore){c',L,'=c',L,'.data.items;n',L,'=c',L,'.length;}else{c',L,'=[c',L,'];n',L,'=1;}}\n',
+            'for (xcount=n',L,';i',L,'<n'+L+';++i',L,'){\n',
+            'values=c',L,'[i',L,']');
+        if (actions.propName) {
+            me.body.push('.', actions.propName);
+        }
+        me.body.push('\n',
+            'xindex=i',L,'+1\n');
+    },
+
+    createArrayTest: ('isArray' in Array) ? function(L) {
+        return 'Array.isArray(c' + L + ')';
+    } : function(L) {
+        return 'ts.call(c' + L + ')==="[object Array]"';
+    },
+
+    doExec: function (action, actions) {
+        var me = this,
+            name = 'f' + me.definitions.length;
+
+        me.definitions.push('function ' + name + '(' + me.fnArgs + ') {',
+                            ' try { with(values) {',
+                            '  ' + action,
+                            ' }} catch(e) {',
+                            '}',
+                      '}');
+
+        me.body.push(name + me.callFn + '\n');
+    },
+
+    
+    
+
+    addFn: function (body) {
+        var me = this,
+            name = 'f' + me.definitions.length;
+
+        if (body === '.') {
+            me.definitions.push('function ' + name + '(' + me.fnArgs + ') {',
+                            ' return values',
+                       '}');
+        } else if (body === '..') {
+            me.definitions.push('function ' + name + '(' + me.fnArgs + ') {',
+                            ' return parent',
+                       '}');
+        } else {
+            me.definitions.push('function ' + name + '(' + me.fnArgs + ') {',
+                            ' try { with(values) {',
+                            '  return(' + body + ')',
+                            ' }} catch(e) {',
+                            '}',
+                       '}');
+        }
+
+        return name;
+    },
+
+    parseTag: function (tag) {
+        var me = this,
+            m = me.tagRe.exec(tag),
+            name = m[1],
+            format = m[2],
+            args = m[3],
+            math = m[4],
+            v;
+
+        
+        if (name == '.') {
+            
+            if (!me.validTypes) {
+                me.definitions.push('var validTypes={string:1,number:1,boolean:1};');
+                me.validTypes = true;
+            }
+            v = 'validTypes[typeof values] || ts.call(values) === "[object Date]" ? values : ""';
+        }
+        
+        else if (name == '#') {
+            v = 'xindex';
+        }
+        else if (name.substr(0, 7) == "parent.") {
+            v = name;
+        }
+        
+        else if (isNaN(name) && name.indexOf('-') == -1 && name.indexOf('.') != -1) {
+            v = "values." + name;
+        }
+        
+        
+        else {    
+            v = "values['" + name + "']";
+        }
+
+        if (math) {
+            v = '(' + v + math + ')';
+        }
+
+        if (format && me.useFormat) {
+            args = args ? ',' + args : "";
+            if (format.substr(0, 5) != "this.") {
+                format = "fm." + format + '(';
+            } else {
+                format += '(';
+            }
+        } else {
+            return v;
+        }
+
+        return format + v + args + ')';
+    },
+
+    
+    evalTpl: function ($) {
+
+        
+        
+        
+        
+        eval($);
+        return $;
+    },
+
+    newLineRe: /\r\n|\r|\n/g,
+    aposRe: /[']/g,
+    intRe:  /^\s*(\d+)\s*$/,
+    tagRe:  /([\w-\.\#]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?(\s?[\+\-\*\/]\s?[\d\.\+\-\*\/\(\)]+)?/
+
+}, function () {
+    var proto = this.prototype;
+
+    proto.fnArgs = 'out,values,parent,xindex,xcount';
+    proto.callFn = '.call(this,' + proto.fnArgs + ')';
+});
+
+/**
+ * A template class that supports advanced functionality like:
+ *
+ * - Autofilling arrays using templates and sub-templates
+ * - Conditional processing with basic comparison operators
+ * - Basic math function support
+ * - Execute arbitrary inline code with special built-in template variables
+ * - Custom member functions
+ * - Many special tags and built-in operators that aren't defined as part of the API, but are supported in the templates that can be created
+ *
+ * XTemplate provides the templating mechanism built into {@link Ext.view.View}.
+ *
+ * The {@link Ext.Template} describes the acceptable parameters to pass to the constructor. The following examples
+ * demonstrate all of the supported features.
+ *
+ * # Sample Data
+ *
+ * This is the data object used for reference in each code example:
+ *
+ *     var data = {
+ *         name: 'Don Griffin',
+ *         title: 'Senior Technomage',
+ *         company: 'Sencha Inc.',
+ *         drinks: ['Coffee', 'Water', 'More Coffee'],
+ *         kids: [
+ *             { name: 'Aubrey',  age: 17 },
+ *             { name: 'Joshua',  age: 13 },
+ *             { name: 'Cale',    age: 10 },
+ *             { name: 'Nikol',   age: 5 },
+ *             { name: 'Solomon', age: 0 }
+ *         ]
+ *     };
+ *
+ * # Auto filling of arrays
+ *
+ * The **tpl** tag and the **for** operator are used to process the provided data object:
+ *
+ * - If the value specified in for is an array, it will auto-fill, repeating the template block inside the tpl
+ *   tag for each item in the array.
+ * - If for="." is specified, the data object provided is examined.
+ * - While processing an array, the special variable {#} will provide the current array index + 1 (starts at 1, not 0).
+ *
+ * Examples:
+ *
+ *     <tpl for=".">...</tpl>       
+ *     <tpl for="foo">...</tpl>     
+ *     <tpl for="foo.bar">...</tpl> 
+ *
+ * Using the sample data above:
+ *
+ *     var tpl = new Ext.XTemplate(
+ *         '<p>Kids: ',
+ *         '<tpl for=".">',       
+ *             '<p>{#}. {name}</p>',  
+ *         '</tpl></p>'
+ *     );
+ *     tpl.overwrite(panel.body, data.kids); 
+ *
+ * An example illustrating how the **for** property can be leveraged to access specified members of the provided data
+ * object to populate the template:
+ *
+ *     var tpl = new Ext.XTemplate(
+ *         '<p>Name: {name}</p>',
+ *         '<p>Title: {title}</p>',
+ *         '<p>Company: {company}</p>',
+ *         '<p>Kids: ',
+ *         '<tpl for="kids">',     
+ *             '<p>{name}</p>',
+ *         '</tpl></p>'
+ *     );
+ *     tpl.overwrite(panel.body, data);  
+ *
+ * Flat arrays that contain values (and not objects) can be auto-rendered using the special **`{.}`** variable inside a
+ * loop. This variable will represent the value of the array at the current index:
+ *
+ *     var tpl = new Ext.XTemplate(
+ *         '<p>{name}\'s favorite beverages:</p>',
+ *         '<tpl for="drinks">',
+ *             '<div> - {.}</div>',
+ *         '</tpl>'
+ *     );
+ *     tpl.overwrite(panel.body, data);
+ *
+ * When processing a sub-template, for example while looping through a child array, you can access the parent object's
+ * members via the **parent** object:
+ *
+ *     var tpl = new Ext.XTemplate(
+ *         '<p>Name: {name}</p>',
+ *         '<p>Kids: ',
+ *         '<tpl for="kids">',
+ *             '<tpl if="age &gt; 1">',
+ *                 '<p>{name}</p>',
+ *                 '<p>Dad: {parent.name}</p>',
+ *             '</tpl>',
+ *         '</tpl></p>'
+ *     );
+ *     tpl.overwrite(panel.body, data);
+ *
+ * # Conditional processing with basic comparison operators
+ *
+ * The **tpl** tag and the **if** operator are used to provide conditional checks for deciding whether or not to render
+ * specific parts of the template.
+ *
+ * Using the sample data above:
+ *
+ *     var tpl = new Ext.XTemplate(
+ *         '<p>Name: {name}</p>',
+ *         '<p>Kids: ',
+ *         '<tpl for="kids">',
+ *             '<tpl if="age &gt; 1">',
+ *                 '<p>{name}</p>',
+ *             '</tpl>',
+ *         '</tpl></p>'
+ *     );
+ *     tpl.overwrite(panel.body, data);
+ *
+ * More advanced conditionals are also supported:
+ *
+ *     var tpl = new Ext.XTemplate(
+ *         '<p>Name: {name}</p>',
+ *         '<p>Kids: ',
+ *         '<tpl for="kids">',
+ *             '<p>{name} is a ',
+ *             '<tpl if="age &gt;= 13">',
+ *                 '<p>teenager</p>',
+ *             '<tpl elseif="age &gt;= 2">',
+ *                 '<p>kid</p>',
+ *             '<tpl else>',
+ *                 '<p>baby</p>',
+ *             '</tpl>',
+ *         '</tpl></p>'
+ *     );
+ *
+ *     var tpl = new Ext.XTemplate(
+ *         '<p>Name: {name}</p>',
+ *         '<p>Kids: ',
+ *         '<tpl for="kids">',
+ *             '<p>{name} is a ',
+ *             '<tpl switch="name">',
+ *                 '<tpl case="Aubrey" case="Nikol">',
+ *                     '<p>girl</p>',
+ *                 '<tpl default>',
+ *                     '<p>boy</p>',
+ *             '</tpl>',
+ *         '</tpl></p>'
+ *     );
+ *
+ * A `break` is implied between each case and default, however, multiple cases can be listed
+ * in a single &lt;tpl&gt; tag.
+ *
+ * # Using double quotes
+ *
+ * Examples:
+ *
+ *     var tpl = new Ext.XTemplate(
+ *         "<tpl if='age &gt; 1 && age &lt; 10'>Child</tpl>",
+ *         "<tpl if='age &gt;= 10 && age &lt; 18'>Teenager</tpl>",
+ *         "<tpl if='this.isGirl(name)'>...</tpl>",
+ *         '<tpl if="id == \'download\'">...</tpl>',
+ *         "<tpl if='needsIcon'><img src='{icon}' class='{iconCls}'/></tpl>",
+ *         "<tpl if='name == \"Don\"'>Hello</tpl>"
+ *     );
+ *
+ * # Basic math support
+ *
+ * The following basic math operators may be applied directly on numeric data values:
+ *
+ *     + - * /
+ *
+ * For example:
+ *
+ *     var tpl = new Ext.XTemplate(
+ *         '<p>Name: {name}</p>',
+ *         '<p>Kids: ',
+ *         '<tpl for="kids">',
+ *             '<tpl if="age &gt; 1">',  
+ *                 '<p>{#}: {name}</p>',  
+ *                 '<p>In 5 Years: {age+5}</p>',  
+ *                 '<p>Dad: {parent.name}</p>',
+ *             '</tpl>',
+ *         '</tpl></p>'
+ *     );
+ *     tpl.overwrite(panel.body, data);
+ *
+ * # Execute arbitrary inline code with special built-in template variables
+ *
+ * Anything between `{[ ... ]}` is considered code to be executed in the scope of the template.
+ * The expression is evaluated and the result is included in the generated result. There are
+ * some special variables available in that code:
+ *
+ * - **out**: The output array into which the template is being appended (using `push` to later
+ *   `join`).
+ * - **values**: The values in the current scope. If you are using scope changing sub-templates,
+ *   you can change what values is.
+ * - **parent**: The scope (values) of the ancestor template.
+ * - **xindex**: If you are in a looping template, the index of the loop you are in (1-based).
+ * - **xcount**: If you are in a looping template, the total length of the array you are looping.
+ *
+ * This example demonstrates basic row striping using an inline code block and the xindex variable:
+ *
+ *     var tpl = new Ext.XTemplate(
+ *         '<p>Name: {name}</p>',
+ *         '<p>Company: {[values.company.toUpperCase() + ", " + values.title]}</p>',
+ *         '<p>Kids: ',
+ *         '<tpl for="kids">',
+ *             '<div class="{[xindex % 2 === 0 ? "even" : "odd"]}">',
+ *             '{name}',
+ *             '</div>',
+ *         '</tpl></p>'
+ *      );
+ *
+ * Any code contained in "verbatim" blocks (using "{% ... %}") will be inserted directly in
+ * the generated code for the template. These blocks are not included in the output. This
+ * can be used for simple things like break/continue in a loop, or control structures or
+ * method calls (when they don't produce output). The `this` references the template instance.
+ *
+ *     var tpl = new Ext.XTemplate(
+ *         '<p>Name: {name}</p>',
+ *         '<p>Company: {[values.company.toUpperCase() + ", " + values.title]}</p>',
+ *         '<p>Kids: ',
+ *         '<tpl for="kids">',
+ *             '{% if (xindex % 2 === 0) continue; %}',
+ *             '{name}',
+ *             '{% if (xindex > 100) break; %}',
+ *             '</div>',
+ *         '</tpl></p>'
+ *      );
+ *
+ * # Template member functions
+ *
+ * One or more member functions can be specified in a configuration object passed into the XTemplate constructor for
+ * more complex processing:
+ *
+ *     var tpl = new Ext.XTemplate(
+ *         '<p>Name: {name}</p>',
+ *         '<p>Kids: ',
+ *         '<tpl for="kids">',
+ *             '<tpl if="this.isGirl(name)">',
+ *                 '<p>Girl: {name} - {age}</p>',
+ *             '<tpl else>',
+ *                 '<p>Boy: {name} - {age}</p>',
+ *             '</tpl>',
+ *             '<tpl if="this.isBaby(age)">',
+ *                 '<p>{name} is a baby!</p>',
+ *             '</tpl>',
+ *         '</tpl></p>',
+ *         {
+ *             // XTemplate configuration:
+ *             disableFormats: true,
+ *             // member functions:
+ *             isGirl: function(name){
+ *                return name == 'Aubrey' || name == 'Nikol';
+ *             },
+ *             isBaby: function(age){
+ *                return age < 1;
+ *             }
+ *         }
+ *     );
+ *     tpl.overwrite(panel.body, data);
+ */
+Ext.define('Ext.XTemplate', {
+    extend: 'Ext.Template',
+
+    requires: 'Ext.XTemplateCompiler',
+
+    /**
+     * @private
+     */
+    emptyObj: {},
+
+    /**
+     * @cfg {Boolean} compiled
+     * Only applies to {@link Ext.Template}, XTemplates are compiled automatically on the
+     * first call to {@link #apply} or {@link #applyOut}.
+     */
+
+    /**
+     * @cfg {String/Array} definitions
+     * Optional. A statement, or array of statements which set up `var`s which may then
+     * be accessed within the scope of the generated function.
+     */
+
+    apply: function(values, parent) {
+        return this.applyOut(values, [], parent).join('');
+    },
+
+    applyOut: function(values, out, parent) {
+        var me = this,
+            compiler;
+
+        if (!me.fn) {
+            compiler = new Ext.XTemplateCompiler({
+                useFormat: me.disableFormats !== true,
+                definitions: me.definitions
+            });
+
+            me.fn = compiler.compile(me.html);
+        }
+
+        try {
+            me.fn.call(me, out, values, parent || me.emptyObj, 1, 1);
+        } catch (e) {
+        }
+
+        return out;
+    },
+
+    /**
+     * Does nothing. XTemplates are compiled automatically, so this function simply returns this.
+     * @return {Ext.XTemplate} this
+     */
+    compile: function() {
+        return this;
+    },
+
+    statics: {
+        /**
+         * Gets an `XTemplate` from an object (an instance of an {@link Ext#define}'d class).
+         * Many times, templates are configured high in the class hierarchy and are to be
+         * shared by all classes that derive from that base. To further complicate matters,
+         * these templates are seldom actual instances but are rather configurations. For
+         * example:
+         * 
+         *      Ext.define('MyApp.Class', {
+         *          someTpl: [
+         *              'tpl text here'
+         *          ]
+         *      });
+         * 
+         * The goal being to share that template definition with all instances and even
+         * instances of derived classes, until `someTpl` is overridden. This method will
+         * "upgrade" these configurations to be real `XTemplate` instances *in place* (to
+         * avoid creating one instance per object).
+         *
+         * @param {Object} instance The object from which to get the `XTemplate` (must be
+         * an instance of an {@link Ext#define}'d class).
+         * @param {String} name The name of the property by which to get the `XTemplate`.
+         * @return {Ext.XTemplate} The `XTemplate` instance or null if not found.
+         * @protected
+         */
+        getTpl: function (instance, name) {
+            var tpl = instance[name], // go for it! 99% of the time we will get it!
+                proto;
+
+            if (tpl && !tpl.isTemplate) { // tpl is just a configuration (not an instance)
+                // create the template instance from the configuration:
+                tpl = Ext.ClassManager.dynInstantiate('Ext.XTemplate', tpl);
+
+                // and replace the reference with the new instance:
+                if (instance.hasOwnProperty(name)) { // the tpl is on the instance
+                    instance[name] = tpl;
+                } else { // must be somewhere in the prototype chain
+                    for (proto = instance.self.prototype; proto; proto = proto.superclass) {
+                        if (proto.hasOwnProperty(name)) {
+                            proto[name] = tpl;
+                            break;
+                        }
+                    }
+                }
+            }
+            // else !tpl (no such tpl) or the tpl is an instance already... either way, tpl
+            // is ready to return
+
+            return tpl || null;
+        }
+    }
+});
+
+/**
+ * Base Layout class - extended by ComponentLayout and ContainerLayout
+ */
+Ext.define('Ext.layout.Layout', {
+
+    requires: [
+        'Ext.XTemplate'
+    ],
+
+    uses: [ 'Ext.layout.Context' ],
+
+    /**
+     * @property {Boolean} isLayout
+     * `true` in this class to identify an object as an instantiated Layout, or subclass thereof.
+     */
+    isLayout: true,
+    initialized: false,
+    running: false,
+
+    autoSizePolicy: {
+        setsWidth: 0,
+        setsHeight: 0
+    },
+
+    statics: {
+        layoutsByType: {},
+
+        create: function(layout, defaultType) {
+            var ClassManager = Ext.ClassManager,
+                layoutsByType = this.layoutsByType,
+                alias, className, config, layoutClass, type, load;
+
+            if (!layout || typeof layout === 'string') {
+                type = layout || defaultType;
+                config = {};                    
+            } else if (layout.isLayout) {
+                return layout;
+            } else {
+                config = layout;
+                type = layout.type || defaultType;
+            }
+
+            if (!(layoutClass = layoutsByType[type])) {
+                alias = 'layout.' + type;
+                className = ClassManager.getNameByAlias(alias);
+
+                // this is needed to support demand loading of the class
+                if (!className) {
+                    load = true;
+                }
+                
+                layoutClass = ClassManager.get(className);
+                if (load || !layoutClass) {
+                    return ClassManager.instantiateByAlias(alias, config || {});
+                }
+                layoutsByType[type] = layoutClass;
+            }
+
+            return new layoutClass(config);
+        }
+    },
+
+    constructor : function(config) {
+        var me = this;
+
+        me.id = Ext.id(null, me.type + '-');
+        Ext.apply(me, config);
+        me.layoutCount = 0;
+    },
+
+    /**
+     * @property {Boolean} done Used only during a layout run, this value indicates that a
+     * layout has finished its calculations. This flag is set to true prior to the call to
+     * {@link #calculate} and should be set to false if this layout has more work to do.
+     */
+
+    /**
+     * Called before any calculation cycles to prepare for layout.
+     * 
+     * This is a write phase and DOM reads should be strictly avoided when overridding
+     * this method.
+     * 
+     * @param {Ext.layout.ContextItem} ownerContext The context item for the layout's owner
+     * component.
+     * @method beginLayout
+     */
+    beginLayout: Ext.emptyFn,
+
+    
+    beginLayoutCycle: function (ownerContext) {
+        var me = this,
+            context = me.context,
+            changed;
+
+        if (me.lastWidthModel != ownerContext.widthModel) {
+            if (me.lastWidthModel) {
+                changed = true;
+            }
+            me.lastWidthModel = ownerContext.widthModel;
+        }
+
+        if (me.lastHeightModel != ownerContext.heightModel) {
+            if (me.lastWidthModel) {
+                changed = true;
+            }
+            me.lastHeightModel = ownerContext.heightModel;
+        }
+
+        if (changed) {
+            (context = ownerContext.context).clearTriggers(me, false);
+            context.clearTriggers(me, true);
+            me.triggerCount = 0;
+        }
+    },
+
+    
+
+    
+
+    
+
+    
+    finishedLayout: function () {
+        this.ownerContext = null;
+    },
+    
+    
+    
+    redoLayout: Ext.emptyFn,
+    undoLayout: Ext.emptyFn,
+
+    getAnimatePolicy: function() {
+        return this.animatePolicy;
+    },
+
+    
+    getItemSizePolicy: function (item) {
+        return this.autoSizePolicy;
+    },
+
+    isItemBoxParent: function (itemContext) {
+        return false;
+    },
+
+    isItemLayoutRoot: function (item) {
+        var sizeModel = item.getSizeModel(),
+            width = sizeModel.width,
+            height = sizeModel.height;
+
+        
+        
+        if (!item.componentLayout.lastComponentSize && (width.calculated || height.calculated)) {
+            return false;
+        }
+
+        
+        return !width.shrinkWrap && !height.shrinkWrap;
+    },
+
+    isItemShrinkWrap: function (item) {
+        return item.shrinkWrap;
+    },
+
+    isRunning: function () {
+        return !!this.ownerContext;
+    },
+
+    
+    
+    
+
+    getItemsRenderTree: function (items, renderCfgs) {
+        var length = items.length,
+            i, item, itemConfig, result;
+
+        if (length) {
+            result = [];
+            for (i = 0; i < length; ++i) {
+                item = items[i];
+
+                
+                
+                if (!item.rendered) {
+
+                    
+                    
+                    
+                    
+                    
+                    if (renderCfgs && (renderCfgs[item.id] !== undefined)) {
+                        itemConfig = renderCfgs[item.id];
+                    } else {
+                        
+                        this.configureItem(item);
+                        itemConfig = item.getRenderTree();
+                        if (renderCfgs) {
+                            renderCfgs[item.id] = itemConfig;
+                        }
+                    }
+
+                    
+                    if (itemConfig) {
+                        result.push(itemConfig);
+                    }
+                }
+            }
+        }
+
+        return result;
+    },
+
+    finishRender: Ext.emptyFn,
+
+    finishRenderItems: function (target, items) {
+        var length = items.length,
+            i, item;
+
+        for (i = 0; i < length; i++) {
+            item = items[i];
+
+            
+            if (item.rendering) {
+
+                
+                item.finishRender(i);
+
+                this.afterRenderItem(item);
+            }
+        }
+    },
+
+    renderChildren: function () {
+        var me = this,
+            items = me.getLayoutItems(),
+            target = me.getRenderTarget();
+
+        me.renderItems(items, target);
+    },
+
+    
+    renderItems : function(items, target) {
+        var me = this,
+            ln = items.length,
+            i = 0,
+            item;
+
+        if (ln) {
+            Ext.suspendLayouts();
+            for (; i < ln; i++) {
+                item = items[i];
+                if (item && !item.rendered) {
+                    me.renderItem(item, target, i);
+                } else if (!me.isValidParent(item, target, i)) {
+                    me.moveItem(item, target, i);
+                } else {
+                    
+                    me.configureItem(item);
+                }
+            }
+            Ext.resumeLayouts(true);
+        }
+    },
+
+    
+    isValidParent : function(item, target, position) {
+        var itemDom = item.el ? item.el.dom : Ext.getDom(item),
+            targetDom = (target && target.dom) || target;
+
+        
+        if (itemDom.parentNode && itemDom.parentNode.className.indexOf(Ext.baseCSSPrefix + 'resizable-wrap') !== -1) {
+            itemDom = itemDom.parentNode;
+        }
+
+        
+        if (itemDom && targetDom) {
+            if (typeof position == 'number') {
+                return itemDom === targetDom.childNodes[position];
+            }
+            return itemDom.parentNode === targetDom;
+        }
+
+        return false;
+    },
+
+    
+    configureItem: function(item) {
+        item.ownerLayout = this;
+    },
+
+    
+    renderItem : function(item, target, position) {
+        var me = this;
+        if (!item.rendered) {
+            me.configureItem(item);
+            item.render(target, position);
+            me.afterRenderItem(item);
+        }
+    },
+
+    
+    moveItem : function(item, target, position) {
+        target = target.dom || target;
+        if (typeof position == 'number') {
+            position = target.childNodes[position];
+        }
+        target.insertBefore(item.el.dom, position || null);
+        item.container = Ext.get(target);
+        this.configureItem(item);
+    },
+
+    
+    onContentChange: function () {
+        this.owner.updateLayout();
+        return true;
+    },
+
+    
+    initLayout : function() {
+        this.initialized = true;
+    },
+
+    
+    setOwner : function(owner) {
+        this.owner = owner;
+    },
+
+    
+    getLayoutItems : function() {
+        return [];
+    },
+
+    
+    afterRenderItem: Ext.emptyFn,
+    onAdd : Ext.emptyFn,
+    onRemove : Ext.emptyFn,
+    onDestroy : Ext.emptyFn,
+
+    
+    afterRemove : function(item) {
+        var me = this,
+            el = item.el,
+            owner = me.owner,
+            removeClasses;
+
+        if (item.rendered) {
+            removeClasses = [].concat(me.itemCls || []);
+            if (owner.itemCls) {
+                removeClasses = Ext.Array.push(removeClasses, owner.itemCls);
+            }
+            if (removeClasses.length) {
+                el.removeCls(removeClasses);
+            }
+        }
+
+        delete item.ownerLayout;
+    },
+
+    
+    destroy : function() {
+        var me = this,
+            target;
+
+        if (me.targetCls) {
+            target = me.getTarget();
+            if (target) {
+                target.removeCls(me.targetCls);
+            }
+        }
+
+        me.onDestroy();
+    },
+
+    sortWeightedItems: function (items, reverseProp) {
+        for (var i = 0, length = items.length; i < length; ++i) {
+            items[i].$i = i;
+        }
+
+        Ext.Array.sort(items, function (item1, item2) {
+            var ret = item2.weight - item1.weight;
+
+            if (!ret) {
+                ret = item1.$i - item2.$i;
+                if (item1[reverseProp]) {
+                    ret = -ret;
+                }
+            }
+
+            return ret;
+        });
+
+        for (i = 0; i < length; ++i) {
+            delete items[i].$i;
+        }
+    }
+}, function () {
+    var Layout = this,
+        sizeModels = {},
+        sizeModelsArray = [],
+        i, j, n, pairs, sizeModel;
+
+    Layout.prototype.sizeModels = Layout.sizeModels = sizeModels;
+
+    
+    var SizeModel = function (config) {
+        var me = this,
+            name = config.name;
+
+        Ext.apply(Ext.apply(me, defaults), config);
+
+        me[name] = true; 
+        SizeModel[name] = sizeModels[name] = me;
+
+        me.fixed = !(me.auto = me.natural || me.shrinkWrap);
+
+        
+        me.ordinal = sizeModelsArray.length;
+        sizeModelsArray.push(me);
+    };
+
+    Ext.layout.SizeModel = SizeModel;
+
+    var defaults = {
+        
+
+        
+
+        
+        calculated: false,
+
+        
+        configured: false,
+
+        
+        constrainedMax: false,
+
+        
+        constrainedMin: false,
+
+        
+
+        
+        natural: false,
+
+        
+        shrinkWrap: false,
+
+        
+        calculatedFromConfigured: false,
+
+        
+        calculatedFromNatural: false,
+
+        
+        calculatedFromShrinkWrap: false,
+
+        
+        names: null
+    };
+
+    
+    
+
+    new SizeModel({
+        name: 'calculated'
+    });
+
+    new SizeModel({
+        name: 'configured',
+        names: { width: 'width', height: 'height' }
+    });
+
+    new SizeModel({
+        name: 'natural'
+    });
+
+    new SizeModel({
+        name: 'shrinkWrap'
+    });
+
+    
+    
+    
+
+    new SizeModel({
+        name: 'calculatedFromConfigured',
+        configured: true,
+        names: { width: 'width', height: 'height' }
+    });
+
+    new SizeModel({
+        name: 'calculatedFromNatural',
+        natural: true
+    });
+
+    new SizeModel({
+        name: 'calculatedFromShrinkWrap',
+        shrinkWrap: true
+    });
+
+    new SizeModel({
+        name: 'constrainedMax',
+        configured: true,
+        constrained: true,
+        names: { width: 'maxWidth', height: 'maxHeight' }
+    });
+
+    new SizeModel({
+        name: 'constrainedMin',
+        configured: true,
+        constrained: true,
+        names: { width: 'minWidth', height: 'minHeight' }
+    });
+
+    for (i = 0, n = sizeModelsArray.length; i < n; ++i) {
+        sizeModel = sizeModelsArray[i];
+        
+        sizeModel.pairsByHeightOrdinal = pairs = [];
+
+        for (j = 0; j < n; ++j) {
+            pairs.push({
+                width: sizeModel,
+                height: sizeModelsArray[j]
+            });
+        }
+    }
+});
+
+
+Ext.define('Ext.layout.container.Container', {
+
+    
+
+    extend: 'Ext.layout.Layout',
+
+    alternateClassName: 'Ext.layout.ContainerLayout',
+
+    mixins: {
+        elementCt: 'Ext.util.ElementContainer'
+    },
+
+    requires: [
+        'Ext.XTemplate'
+    ],
+
+    type: 'container',
+
+    
+
+    
+
+    
+    manageOverflow: 0,
+
+    
+    beginCollapse: Ext.emptyFn,
+
+    
+    beginExpand: Ext.emptyFn,
+
+    
+    animatePolicy: null,
+
+    childEls: [
+        
+        'overflowPadderEl'
+    ],
+
+    renderTpl: [
+        '{%this.renderBody(out,values)%}'
+    ],
+
+    usesContainerHeight: true,
+    usesContainerWidth: true,
+    usesHeight: true,
+    usesWidth: true,
+
+
+    
+    reserveScrollbar: false,
+
+    
+    lastOverflowAdjust: {
+        width: 0,
+        height: 0
+    },
+
+    constructor: function () {
+        this.callParent(arguments);
+        this.mixins.elementCt.constructor.call(this);
+    },
+
+    destroy : function() {
+        this.callParent();
+        this.mixins.elementCt.destroy.call(this);
+    },
+
+    initLayout: function() {
+        var me = this,
+            scrollbarWidth = Ext.getScrollbarSize().width;
+
+        me.callParent();
+
+        
+        
+        
+        if (scrollbarWidth && me.manageOverflow && !me.hasOwnProperty('lastOverflowAdjust')) {
+            if (me.owner.autoScroll || me.reserveScrollbar) {
+                me.lastOverflowAdjust = {
+                    width: scrollbarWidth,
+                    height: 0
+                };
+            }
+        }
+    },
+
+    
+    beginLayout: function (ownerContext) {
+        this.callParent(arguments);
+
+        ownerContext.targetContext = ownerContext.getEl('getTarget', this);
+
+        this.cacheChildItems(ownerContext);
+    },
+
+    beginLayoutCycle: function (ownerContext, firstCycle) {
+        var me = this,
+            padEl = me.overflowPadderEl;
+
+        me.callParent(arguments);
+
+        
+        
+        if (!ownerContext.state.overflowAdjust) {
+            ownerContext.state.overflowAdjust = me.lastOverflowAdjust;
+        }
+
+        if (firstCycle) {
+            if (me.usesContainerHeight) {
+                ++ownerContext.consumersContainerHeight;
+            }
+            if (me.usesContainerWidth) {
+                ++ownerContext.consumersContainerWidth;
+            }
+        }
+
+        if (padEl) {
+            padEl.setStyle('display', 'none');
+        }
+    },
+
+    completeLayout: function (ownerContext) {
+        
+        this.lastOverflowAdjust = ownerContext.state.overflowAdjust;
+    },
+
+    cacheChildItems: function (ownerContext) {
+        var context = ownerContext.context,
+            childItems = [],
+            items = this.getVisibleItems(),
+            length = items.length,
+            i;
+
+        ownerContext.childItems = childItems;
+        ownerContext.visibleItems = items;
+
+        for (i = 0; i < length; ++i) {
+            childItems.push(context.getCmp(items[i]));
+        }
+    },
+
+    cacheElements: function () {
+        var owner = this.owner;
+
+        this.applyChildEls(owner.el, owner.id); 
+    },
+
+    calculateContentSize: function (ownerContext, dimensions) {
+        var me = this,
+            containerDimensions = (dimensions || 0) | me.manageOverflow |
+                   ((ownerContext.widthModel.shrinkWrap ? 1 : 0) |
+                    (ownerContext.heightModel.shrinkWrap ? 2 : 0)),
+            calcWidth = (containerDimensions & 1) || undefined,
+            calcHeight = (containerDimensions & 2) || undefined,
+            childItems = ownerContext.childItems,
+            length = childItems.length,
+            contentHeight = 0,
+            contentWidth = 0,
+            needed = 0,
+            props = ownerContext.props,
+            targetXY, targetX, targetY, targetPadding,
+            borders, child, childContext, childX, childY, height, i, margins, width, xy;
+
+        if (calcWidth) {
+            if (isNaN(props.contentWidth)) {
+                ++needed;
+            } else {
+                calcWidth = undefined;
+            }
+        }
+        if (calcHeight) {
+            if (isNaN(props.contentHeight)) {
+                ++needed;
+            } else {
+                calcHeight = undefined;
+            }
+        }
+
+        if (needed) {
+            
+            
+            
+            for (i = 0; i < length; ++i) {
+                childContext = childItems[i];
+                child = childContext.target;
+                height = calcHeight && childContext.getProp('height');
+                width = calcWidth && childContext.getProp('width');
+                margins = childContext.getMarginInfo();
+
+                
+                
+                if ((calcWidth && isNaN(child.x)) || (calcHeight && isNaN(child.y))) {
+                    xy = child.el.getXY();
+                    if (!targetXY) {
+                        targetXY = ownerContext.targetContext.el.getXY();
+                        borders = ownerContext.targetContext.getBorderInfo();
+                        targetX = targetXY[0] + borders.left;
+                        targetY = targetXY[1] + borders.top;
+                    }
+                    
+                    childX = xy[0] - targetX;
+                    childY = xy[1] - targetY;
+                } else {
+                    
+                    childX = child.x;
+                    childY = child.y;
+                }
+                
+
+                height += margins.bottom;
+                width  += margins.right;
+
+                contentHeight = Math.max(contentHeight, childY + height);
+                contentWidth = Math.max(contentWidth, childX + width);
+
+                if (isNaN(contentHeight) && isNaN(contentWidth)) {
+                    me.done = false;
+                    return;
+                }
+            }
+
+            if (calcWidth || calcHeight) {
+                targetPadding = ownerContext.targetContext.getPaddingInfo();
+            }
+            if (calcWidth && !ownerContext.setContentWidth(contentWidth + targetPadding.right)) {
+                me.done = false;
+            }
+            if (calcHeight && !ownerContext.setContentHeight(contentHeight + targetPadding.bottom)) {
+                me.done = false;
+            }
+
+            
+        }
+    },
+
+    
+    calculateOverflow: function (ownerContext, containerSize, dimensions) {
+        var me = this,
+            owner = me.owner,
+            manageOverflow = me.manageOverflow,
+            state = ownerContext.state,
+            overflowAdjust = state.overflowAdjust,
+            padWidth, padHeight, padElContext, padding, scrollRangeFlags,
+            overflow, scrollbarSize, contentW, contentH, ownerW, ownerH, scrollbars,
+            xauto, yauto;
+
+        if (manageOverflow && !state.secondPass && !me.reserveScrollbar) {
+            
+            
+            if (owner.autoScroll) {
+                xauto = yauto = true;
+            } else {
+                if (owner.overflowX) {
+                    xauto = owner.overflowX == 'auto';
+                } else {
+                    overflow = ownerContext.targetContext.getStyle('overflow-x');
+                    xauto = overflow && overflow != 'hidden' && overflow != 'scroll';
+                }
+
+                if (owner.overflowY) {
+                    yauto = owner.overflowY == 'auto';
+                } else {
+                    overflow = ownerContext.targetContext.getStyle('overflow-y');
+                    yauto = overflow && overflow != 'hidden' && overflow != 'scroll';
+                }
+            }
+
+            
+            
+            
+            if (!containerSize.gotWidth) {
+                xauto = false;
+            }
+            if (!containerSize.gotHeight) {
+                yauto = false;
+            }
+
+            if (xauto || yauto) {
+                scrollbarSize = Ext.getScrollbarSize();
+
+                
+                
+                contentW = ownerContext.peek('contentWidth');
+                contentH = ownerContext.peek('contentHeight');
+                ownerW = containerSize.width;
+                ownerH = containerSize.height;
+
+                scrollbars = me.getScrollbarsNeeded(ownerW, ownerH, contentW, contentH);
+                state.overflowState = scrollbars;
+
+                if (typeof dimensions == 'number') {
+                    scrollbars &= ~dimensions; 
+                }
+
+                overflowAdjust = {
+                    width:  (xauto && (scrollbars & 2)) ? scrollbarSize.width : 0,
+                    height: (yauto && (scrollbars & 1)) ? scrollbarSize.height : 0
+                };
+
+                
+                
+                if (overflowAdjust.width !== me.lastOverflowAdjust.width || overflowAdjust.height !== me.lastOverflowAdjust.height) {
+                    me.done = false;
+
+                    
+                    
+                    ownerContext.invalidate({
+                        state: {
+                            overflowAdjust: overflowAdjust,
+                            overflowState: state.overflowState,
+                            secondPass: true
+                        }
+                    });
+                }
+            }
+        }
+
+        if (!me.done) {
+            return;
+        }
+
+        padElContext = ownerContext.padElContext ||
+                      (ownerContext.padElContext = ownerContext.getEl('overflowPadderEl', me));
+
+        
+        
+        if (padElContext) {
+            scrollbars = state.overflowState; 
+            padWidth = containerSize.width;
+            padHeight = 0;
+
+            if (scrollbars) {
+                padding = ownerContext.targetContext.getPaddingInfo();
+                scrollRangeFlags = me.scrollRangeFlags;
+
+                if ((scrollbars & 2) && (scrollRangeFlags & 1)) { 
+                    padHeight += padding.bottom;
+                }
+
+                if ((scrollbars & 1) && (scrollRangeFlags & 4)) { 
+                    padWidth += padding.right;
+                }
+                padElContext.setProp('display', '');
+                padElContext.setSize(padWidth, padHeight);
+            } else {
+                padElContext.setProp('display', 'none');
+            }
+        }
+    },
+
+    
+    configureItem: function(item) {
+        var me = this,
+            ownerItemCls = me.owner.itemCls,
+            addClasses = [].concat(me.itemCls || []);
+
+        me.callParent(arguments);
+
+        if (ownerItemCls) {
+            addClasses = Ext.Array.push(addClasses, ownerItemCls);
+        }
+        item.addCls(addClasses);
+    },
+
+    doRenderBody: function (out, renderData) {
+        
+        
+
+        this.renderItems(out, renderData);
+        this.renderContent(out, renderData);
+    },
+
+    doRenderContainer: function (out, renderData) {
+        
+        
+
+        var me = renderData.$comp.layout,
+            tpl = me.getRenderTpl(),
+            data = me.getRenderData();
+
+        tpl.applyOut(data, out);
+    },
+
+    doRenderItems: function (out, renderData) {
+        
+        
+
+        var me = renderData.$layout,
+            tree = me.getRenderTree();
+
+        if (tree) {
+            Ext.DomHelper.generateMarkup(tree, out);
+        }
+    },
+
+    
+    doRenderPadder: function (out, renderData) {
+        
+        
+
+        var me = renderData.$layout,
+            owner = me.owner,
+            scrollRangeFlags = me.getScrollRangeFlags();
+
+        if (me.manageOverflow == 2) {
+            if (scrollRangeFlags & 5) { 
+                out.push('<div id="',owner.id,'-overflowPadderEl" ',
+                    'style="font-size: 1px; width:1px; height: 1px;');
+
+                
+                
+                
+                
+                
+                
+                
+
+                out.push('"></div>');
+
+                me.scrollRangeFlags = scrollRangeFlags; 
+            }
+        }
+    }, 
+
+    finishRender: function () {
+        var me = this,
+            target, items;
+
+        me.callParent();
+
+        me.cacheElements();
+
+        target = me.getRenderTarget();
+        items = me.getLayoutItems();
+
+        if (me.targetCls) {
+            me.getTarget().addCls(me.targetCls);
+        }
+
+        me.finishRenderItems(target, items);
+    },
+
+    
+    notifyOwner: function() {
+        this.owner.afterLayout(this);
+    },
+
+    
+    getContainerSize : function(ownerContext, inDom) {
+        
+        
+        
+        
+        
+
+        var targetContext = ownerContext.targetContext,
+            frameInfo = targetContext.getFrameInfo(),
+            padding = targetContext.getPaddingInfo(),
+            got = 0,
+            needed = 0,
+            overflowAdjust = ownerContext.state.overflowAdjust,
+            gotWidth, gotHeight, width, height;
+
+        
+        
+        
+
+        
+        
+        
+
+        if (!ownerContext.widthModel.shrinkWrap) {
+            ++needed;
+            width = inDom ? targetContext.getDomProp('width') : targetContext.getProp('width');
+            gotWidth = (typeof width == 'number');
+            if (gotWidth) {
+                ++got;
+                width -= frameInfo.width + padding.width;
+                if (overflowAdjust) {
+                    width -= overflowAdjust.width;
+                }
+            }
+        }
+
+        if (!ownerContext.heightModel.shrinkWrap) {
+            ++needed;
+            height = inDom ? targetContext.getDomProp('height') : targetContext.getProp('height');
+            gotHeight = (typeof height == 'number');
+            if (gotHeight) {
+                ++got;
+                height -= frameInfo.height + padding.height;
+                if (overflowAdjust) {
+                    height -= overflowAdjust.height;
+                }
+            }
+        }
+
+        return {
+            width: width,
+            height: height,
+            needed: needed,
+            got: got,
+            gotAll: got == needed,
+            gotWidth: gotWidth,
+            gotHeight: gotHeight
+        };
+    },
+
+    
+    getLayoutItems: function() {
+        var owner = this.owner,
+            items = owner && owner.items;
+
+        return (items && items.items) || [];
+    },
+
+    getRenderData: function () {
+        var comp = this.owner;
+
+        return {
+            $comp: comp,
+            $layout: this,
+            ownerId: comp.id
+        };
+    },
+
+    
+    getRenderedItems: function() {
+        var me = this,
+            target = me.getRenderTarget(),
+            items = me.getLayoutItems(),
+            ln = items.length,
+            renderedItems = [],
+            i, item;
+
+        for (i = 0; i < ln; i++) {
+            item = items[i];
+            if (item.rendered && me.isValidParent(item, target, i)) {
+                renderedItems.push(item);
+            }
+        }
+
+        return renderedItems;
+    },
+
+    
+    getRenderTarget: function() {
+        return this.owner.getTargetEl();
+    },
+
+    
+    getElementTarget: function() {
+        return this.getRenderTarget();
+    },
+
+    getRenderTpl: function () {
+        var me = this,
+            renderTpl = Ext.XTemplate.getTpl(this, 'renderTpl');
+
+        
+        
+        if (!renderTpl.renderContent) {
+            me.owner.setupRenderTpl(renderTpl);
+        }
+
+        return renderTpl;
+    },
+
+    getRenderTree: function () {
+        var result,
+            items = this.owner.items,
+            itemsGen,
+            renderCfgs = {};
+        
+        do {
+            itemsGen = items.generation;
+            result = this.getItemsRenderTree(this.getLayoutItems(), renderCfgs);
+        } while (items.generation !== itemsGen);
+        return result;
+    },
+
+    getScrollbarsNeeded: function (width, height, contentWidth, contentHeight) {
+        var scrollbarSize = Ext.getScrollbarSize(),
+            hasWidth = typeof width == 'number',
+            hasHeight = typeof height == 'number',
+            needHorz = 0,
+            needVert = 0;
+
+        
+        if (!scrollbarSize.width) {
+            return 0;
+        }
+        if (hasHeight && height < contentHeight) {
+            needVert = 2;
+            width -= scrollbarSize.width;
+        }
+
+        if (hasWidth && width < contentWidth) {
+            needHorz = 1;
+            if (!needVert && hasHeight) {
+                height -= scrollbarSize.height;
+                if (height < contentHeight) {
+                    needVert = 2;
+                }
+            }
+        }
+
+        return needVert + needHorz;
+    },
+
+    
+    getScrollRangeFlags: (function () {
+        var flags = -1;
+
+        return function () {
+            if (flags < 0) {
+                var div = Ext.getBody().createChild({
+                        
+                        cls: Ext.baseCSSPrefix + 'border-box',
+                        style: {
+                            width: '100px', height: '100px', padding: '10px',
+                            overflow: 'auto'
+                        },
+                        children: [{
+                            style: {
+                                border: '1px solid red',
+                                width: '150px', height: '150px',
+                                margin: '0 5px 5px 0' 
+                            }
+                        }]
+                    }),
+                    scrollHeight = div.dom.scrollHeight,
+                    scrollWidth = div.dom.scrollWidth,
+                    heightFlags = {
+                        
+                        175: 0,
+                        
+                        165: 1,
+                        
+                        170: 2,
+                        
+                        160: 3
+                    },
+                    widthFlags = {
+                        
+                        175: 0,
+                        
+                        165: 4,
+                        
+                        170: 8,
+                        
+                        160: 12
+                    };
+
+                flags = (heightFlags[scrollHeight] || 0) | (widthFlags[scrollWidth] || 0);
+                
+                div.remove();
+            }
+
+            return flags;
+        };
+    }()),
+
+    
+    getTarget: function() {
+        return this.owner.getTargetEl();
+    },
+
+    
+    getVisibleItems: function() {
+        var target   = this.getRenderTarget(),
+            items = this.getLayoutItems(),
+            ln = items.length,
+            visibleItems = [],
+            i, item;
+
+        for (i = 0; i < ln; i++) {
+            item = items[i];
+            if (item.rendered && this.isValidParent(item, target, i) && item.hidden !== true) {
+                visibleItems.push(item);
+            }
+        }
+
+        return visibleItems;
+    },
+
+    setupRenderTpl: function (renderTpl) {
+        var me = this;
+
+        renderTpl.renderBody = me.doRenderBody;
+        renderTpl.renderContainer = me.doRenderContainer;
+        renderTpl.renderItems = me.doRenderItems;
+        renderTpl.renderPadder = me.doRenderPadder;
+    }
+});
+
+
+Ext.define('Ext.layout.container.Editor', {
+
+    
+
+    alias: 'layout.editor',
+
+    extend: 'Ext.layout.container.Container',
+
+    
+
+    autoSizeDefault: {
+        width: 'field',
+        height: 'field'    
+    },
+
+    getItemSizePolicy: function (item) {
+        var me = this,
+            autoSize = me.owner.autoSize;
+
+        return me.sizePolicy || (me.sizePolicy = {
+            setsWidth:  autoSize && autoSize.width  === 'boundEl' ? 1 : 0,
+            setsHeight: autoSize && autoSize.height === 'boundEl' ? 1 : 0
+        });
+    },
+
+    calculate: function(ownerContext) {
+        var me = this,
+            owner = me.owner,
+            autoSize = owner.autoSize,
+            fieldWidth,
+            fieldHeight;
+            
+        if (autoSize === true) {
+            autoSize = me.autoSizeDefault;
+        }
+
+        
+        if (autoSize) {
+            fieldWidth  = me.getDimension(owner, autoSize.width,  'getWidth',  owner.width);
+            fieldHeight = me.getDimension(owner, autoSize.height, 'getHeight', owner.height);
+        }
+
+        
+        ownerContext.childItems[0].setSize(fieldWidth, fieldHeight);
+
+        
+        ownerContext.setWidth(fieldWidth);
+        ownerContext.setHeight(fieldHeight);
+
+        
+        ownerContext.setContentSize(fieldWidth || owner.field.getWidth(),
+                                    fieldHeight || owner.field.getHeight());
+    },
+
+    getDimension: function(owner, type, getMethod, ownerSize){
+        switch (type) {
+            
+            case 'boundEl':
+                return owner.boundEl[getMethod]();
+
+            
+            case 'field':
+                return undefined;
+
+            
+            default:
+                return ownerSize;
+        }
+    }
+});
+
+
+Ext.define('Ext.layout.component.Component', {
+
+    
+
+    extend: 'Ext.layout.Layout',
+
+    
+
+    type: 'component',
+
+    isComponentLayout: true,
+
+    nullBox: {},
+
+    usesContentHeight: true,
+    usesContentWidth: true,
+    usesHeight: true,
+    usesWidth: true,
+
+    beginLayoutCycle: function (ownerContext, firstCycle) {
+        var me = this,
+            owner = me.owner,
+            ownerCtContext = ownerContext.ownerCtContext,
+            heightModel = ownerContext.heightModel,
+            widthModel = ownerContext.widthModel,
+            body = owner.el.dom === document.body,
+            lastBox = owner.lastBox || me.nullBox,
+            lastSize = owner.el.lastBox || me.nullBox,
+            dirty = !body,
+            ownerLayout, v, widthName, heightName;
+
+        me.callParent(arguments);
+
+        if (firstCycle) {
+            if (me.usesContentWidth) {
+                ++ownerContext.consumersContentWidth;
+            }
+            if (me.usesContentHeight) {
+                ++ownerContext.consumersContentHeight;
+            }
+            if (me.usesWidth) {
+                ++ownerContext.consumersWidth;
+            }
+            if (me.usesHeight) {
+                ++ownerContext.consumersHeight;
+            }
+
+            if (ownerCtContext && !ownerCtContext.hasRawContent) {
+                ownerLayout = owner.ownerLayout;
+
+                if (ownerLayout.usesWidth) {
+                    ++ownerContext.consumersWidth;
+                }
+                if (ownerLayout.usesHeight) {
+                    ++ownerContext.consumersHeight;
+                }
+            }
+        }
+
+        
+        
+
+        if (widthModel.configured) {
+            
+            
+            
+            
+            widthName = widthModel.names.width;
+
+            if (!body) {
+                dirty = firstCycle ? owner[widthName] !== lastSize.width
+                                   : widthModel.constrained;
+            }
+            
+            ownerContext.setWidth(owner[widthName], dirty);
+        } else if (ownerContext.isTopLevel) {
+            if (widthModel.calculated) {
+                v = lastBox.width;
+                ownerContext.setWidth(v, v != lastSize.width);
+            }
+
+            v = lastBox.x;
+            ownerContext.setProp('x', v, v != lastSize.x);
+        }
+
+        if (heightModel.configured) {
+            heightName = heightModel.names.height;
+
+            if (!body) {
+                dirty = firstCycle ? owner[heightName] !== lastSize.height
+                                   : heightModel.constrained;
+            }
+
+            ownerContext.setHeight(owner[heightName], dirty);
+        } else if (ownerContext.isTopLevel) {
+            if (heightModel.calculated) {
+                v = lastBox.height;
+                ownerContext.setHeight(v, v != lastSize.height);
+            }
+
+            v = lastBox.y;
+            ownerContext.setProp('y', v, v != lastSize.y);
+        }
+    },
+
+    finishedLayout: function(ownerContext) {
+        var me = this,
+            elementChildren = ownerContext.children,
+            owner = me.owner,
+            len, i, elContext, lastBox, props, v;
+
+        
+
+        
+        
+        if (elementChildren) {
+            len = elementChildren.length;
+            for (i = 0; i < len; i++) {
+                elContext = elementChildren[i];
+                elContext.el.lastBox = elContext.props;
+            }
+        }
+
+        
+        ownerContext.previousSize = me.lastComponentSize;
+
+        
+        me.lastComponentSize = owner.el.lastBox = props = ownerContext.props;
+
+        
+        
+        owner.lastBox = lastBox = {};
+
+        v = props.x;
+        if (v !== undefined) {
+            lastBox.x = v;
+        }
+        v = props.y;
+        if (v !== undefined) {
+            lastBox.y = v;
+        }
+        v = props.width;
+        if (v !== undefined) {
+            lastBox.width = v;
+        }
+        v = props.height;
+        if (v !== undefined) {
+            lastBox.height = v;
+        }
+
+        me.callParent(arguments);
+    },
+    
+    notifyOwner: function(ownerContext) {
+        var me = this,
+            currentSize = me.lastComponentSize,
+            prevSize = ownerContext.previousSize,
+            args = [currentSize.width, currentSize.height];
+
+        if (prevSize) {
+            args.push(prevSize.width, prevSize.height);
+        }
+
+        
+        me.owner.afterComponentLayout.apply(me.owner, args);
+    },
+
+    
+    getTarget : function() {
+        return this.owner.el;
+    },
+
+    
+    getRenderTarget : function() {
+        return this.owner.el;
+    },
+
+    cacheTargetInfo: function(ownerContext) {
+        var me = this,
+            targetInfo = me.targetInfo,
+            target;
+
+        if (!targetInfo) {
+            target = ownerContext.getEl('getTarget', me);
+
+            me.targetInfo = targetInfo = {
+                padding: target.getPaddingInfo(),
+                border: target.getBorderInfo()
+            };
+        }
+
+        return targetInfo;
+    },
+
+    measureAutoDimensions: function (ownerContext, dimensions) {
+        
+        
+        
+        
+        
+
+        var me = this,
+            owner = me.owner,
+            containerLayout = owner.layout,
+            heightModel = ownerContext.heightModel,
+            widthModel = ownerContext.widthModel,
+            boxParent = ownerContext.boxParent,
+            isBoxParent = ownerContext.isBoxParent,
+            props = ownerContext.props,
+            isContainer,
+            ret = {
+                gotWidth: false,
+                gotHeight: false,
+                isContainer: (isContainer = !ownerContext.hasRawContent)
+            },
+            hv = dimensions || 3,
+            zeroWidth, zeroHeight,
+            needed = 0,
+            got = 0,
+            ready, size, temp;
+
+        
+        
+
+        
+        
+
+        if (widthModel.shrinkWrap && ownerContext.consumersContentWidth) {
+            ++needed;
+            zeroWidth = !(hv & 1);
+
+            if (isContainer) {
+                
+                
+                if (zeroWidth) {
+                    ret.contentWidth = 0;
+                    ret.gotWidth = true;
+                    ++got;
+                } else if ((ret.contentWidth = ownerContext.getProp('contentWidth')) !== undefined) {
+                    ret.gotWidth = true;
+                    ++got;
+                }
+            } else {
+                size = props.contentWidth;
+
+                if (typeof size == 'number') { 
+                    ret.contentWidth = size;
+                    ret.gotWidth = true;
+                    ++got;
+                } else {
+                    if (zeroWidth) {
+                        ready = true;
+                    } else if (!ownerContext.hasDomProp('containerChildrenDone')) {
+                        ready = false;
+                    } else if (isBoxParent || !boxParent || boxParent.widthModel.shrinkWrap) {
+                        
+                        
+                        
+                        ready = true;
+                    } else {
+                        
+                        
+                        
+                        ready = boxParent.hasDomProp('width');
+                    }
+
+                    if (ready) {
+                        if (zeroWidth) {
+                            temp = 0;
+                        } else if (containerLayout && containerLayout.measureContentWidth) {
+                            
+                            
+                            temp = containerLayout.measureContentWidth(ownerContext);
+                        } else {
+                            temp = me.measureContentWidth(ownerContext);
+                        }
+
+                        if (!isNaN(ret.contentWidth = temp)) {
+                            ownerContext.setContentWidth(temp, true);
+                            ret.gotWidth = true;
+                            ++got;
+                        }
+                    }
+                }
+            }
+        } else if (widthModel.natural && ownerContext.consumersWidth) {
+            ++needed;
+            size = props.width;
+            
+
+            if (typeof size == 'number') { 
+                ret.width = size;
+                ret.gotWidth = true;
+                ++got;
+            } else {
+                if (isBoxParent || !boxParent) {
+                    ready = true;
+                } else {
+                    
+                    
+                    
+                    ready = boxParent.hasDomProp('width');
+                }
+
+                if (ready) {
+                    if (!isNaN(ret.width = me.measureOwnerWidth(ownerContext))) {
+                        ownerContext.setWidth(ret.width, false);
+                        ret.gotWidth = true;
+                        ++got;
+                    }
+                }
+            }
+        }
+
+        
+        
+
+        if (heightModel.shrinkWrap && ownerContext.consumersContentHeight) {
+            ++needed;
+            zeroHeight = !(hv & 2);
+
+            if (isContainer) {
+                
+                if (zeroHeight) {
+                    ret.contentHeight = 0;
+                    ret.gotHeight = true;
+                    ++got;
+                } else if ((ret.contentHeight = ownerContext.getProp('contentHeight')) !== undefined) {
+                    ret.gotHeight = true;
+                    ++got;
+                }
+            } else {
+                size = props.contentHeight;
+
+                if (typeof size == 'number') { 
+                    ret.contentHeight = size;
+                    ret.gotHeight = true;
+                    ++got;
+                } else {
+                    if (zeroHeight) {
+                        ready = true;
+                    } else if (!ownerContext.hasDomProp('containerChildrenDone')) {
+                        ready = false;
+                    } else if (owner.noWrap) {
+                        ready = true;
+                    } else if (!widthModel.shrinkWrap) {
+                        
+                        ready = (ownerContext.bodyContext || ownerContext).hasDomProp('width');
+                    } else if (isBoxParent || !boxParent || boxParent.widthModel.shrinkWrap) {
+                        
+                        
+                        
+                        ready = true;
+                    } else {
+                        
+                        
+                        
+                        ready = boxParent.hasDomProp('width');
+                    }
+
+                    if (ready) {
+                        if (zeroHeight) {
+                            temp = 0;
+                        } else if (containerLayout && containerLayout.measureContentHeight) {
+                            
+                            
+                            temp = containerLayout.measureContentHeight(ownerContext);
+                        } else {
+                            temp = me.measureContentHeight(ownerContext);
+                        }
+
+                        if (!isNaN(ret.contentHeight = temp)) {
+                            ownerContext.setContentHeight(temp, true);
+                            ret.gotHeight = true;
+                            ++got;
+                        }
+                    }
+                }
+            }
+        } else if (heightModel.natural && ownerContext.consumersHeight) {
+            ++needed;
+            size = props.height;
+            
+
+            if (typeof size == 'number') { 
+                ret.height = size;
+                ret.gotHeight = true;
+                ++got;
+            } else {
+                if (isBoxParent || !boxParent) {
+                    ready = true;
+                } else {
+                    
+                    
+                    
+                    ready = boxParent.hasDomProp('width');
+                }
+
+                if (ready) {
+                    if (!isNaN(ret.height = me.measureOwnerHeight(ownerContext))) {
+                        ownerContext.setHeight(ret.height, false);
+                        ret.gotHeight = true;
+                        ++got;
+                    }
+                }
+            }
+        }
+
+        if (boxParent) {
+            ownerContext.onBoxMeasured();
+        }
+
+        ret.gotAll = got == needed;
+        
+        return ret;
+    },
+
+    measureContentWidth: function (ownerContext) {
+        
+        return ownerContext.el.getWidth() - ownerContext.getFrameInfo().width;
+    },
+
+    measureContentHeight: function (ownerContext) {
+        
+        return ownerContext.el.getHeight() - ownerContext.getFrameInfo().height;
+    },
+
+    measureOwnerHeight: function (ownerContext) {
+        return ownerContext.el.getHeight();
+    },
+
+    measureOwnerWidth: function (ownerContext) {
+        return ownerContext.el.getWidth();
+    }
+});
+
+
+Ext.define('Ext.layout.component.Auto', {
+
+    
+
+    alias: 'layout.autocomponent',
+
+    extend: 'Ext.layout.component.Component',
+
+    
+
+    type: 'autocomponent',
+
+    
+    setHeightInDom: false,
+
+    
+    setWidthInDom: false,
+
+    waitForOuterHeightInDom: false,
+    waitForOuterWidthInDom: false,
+    
+    beginLayoutCycle: function(ownerContext, firstCycle){
+        var me = this,
+            lastWidthModel = me.lastWidthModel,
+            lastHeightModel = me.lastHeightModel,
+            owner = me.owner;
+            
+        me.callParent(arguments);
+            
+        if (lastWidthModel && lastWidthModel.fixed && ownerContext.widthModel.shrinkWrap) {
+            owner.el.setWidth(null);
+        }
+            
+        if (lastHeightModel && lastHeightModel.fixed && ownerContext.heightModel.shrinkWrap) {
+            owner.el.setHeight(null);
+        }    
+    },
+
+    calculate: function(ownerContext) {
+        var me = this,
+            measurement = me.measureAutoDimensions(ownerContext),
+            heightModel = ownerContext.heightModel,
+            widthModel = ownerContext.widthModel,
+            width, height;
+
+        
+        
+        if (measurement.gotWidth) {
+            if (widthModel.shrinkWrap) {
+                me.publishOwnerWidth(ownerContext, measurement.contentWidth);
+            } else if (me.publishInnerWidth) {
+                me.publishInnerWidth(ownerContext, measurement.width);
+            }
+        } else if (!widthModel.auto && me.publishInnerWidth) {
+            width = me.waitForOuterWidthInDom ? ownerContext.getDomProp('width')
+                        : ownerContext.getProp('width');
+            if (width === undefined) {
+                me.done = false;
+            } else {
+                me.publishInnerWidth(ownerContext, width);
+            }
+        }
+
+        if (measurement.gotHeight) {
+            if (heightModel.shrinkWrap) {
+                me.publishOwnerHeight(ownerContext, measurement.contentHeight);
+            } else if (me.publishInnerHeight) {
+                me.publishInnerHeight(ownerContext, measurement.height);
+            }
+        } else if (!heightModel.auto && me.publishInnerHeight) {
+            height = me.waitForOuterHeightInDom ? ownerContext.getDomProp('height')
+                        : ownerContext.getProp('height');
+            if (height === undefined) {
+                me.done = false;
+            } else {
+               me.publishInnerHeight(ownerContext, height);
+            }
+        }
+
+        if (!measurement.gotAll) {
+            me.done = false;
+        }
+    },
+
+    calculateOwnerHeightFromContentHeight: function (ownerContext, contentHeight) {
+        return contentHeight + ownerContext.getFrameInfo().height;
+    },
+
+    calculateOwnerWidthFromContentWidth: function (ownerContext, contentWidth) {
+        return contentWidth + ownerContext.getFrameInfo().width;
+    },
+
+    publishOwnerHeight: function (ownerContext, contentHeight) {
+        var me = this,
+            owner = me.owner,
+            height = me.calculateOwnerHeightFromContentHeight(ownerContext, contentHeight),
+            constrainedHeight, dirty, heightModel;
+
+        if (isNaN(height)) {
+            me.done = false;
+        } else {
+            constrainedHeight = Ext.Number.constrain(height, owner.minHeight, owner.maxHeight);
+
+            if (constrainedHeight == height) {
+                dirty = me.setHeightInDom;
+            } else {
+                heightModel = me.sizeModels[
+                    (constrainedHeight < height) ? 'constrainedMax' : 'constrainedMin'];
+                height = constrainedHeight;
+
+                if (ownerContext.heightModel.calculatedFromShrinkWrap) {
+                    
+                    
+                    
+                    ownerContext.heightModel = heightModel;
+                } else {
+                    ownerContext.invalidate({ heightModel: heightModel });
+                }
+            }
+            
+            ownerContext.setHeight(height, dirty);
+        }
+    },
+
+    publishOwnerWidth: function (ownerContext, contentWidth) {
+        var me = this,
+            owner = me.owner,
+            width = me.calculateOwnerWidthFromContentWidth(ownerContext, contentWidth),
+            constrainedWidth, dirty, widthModel;
+
+        if (isNaN(width)) {
+            me.done = false;
+        } else {
+            constrainedWidth = Ext.Number.constrain(width, owner.minWidth, owner.maxWidth);
+
+            if (constrainedWidth == width) {
+                dirty = me.setWidthInDom;
+            } else {
+                widthModel = me.sizeModels[
+                    (constrainedWidth < width) ? 'constrainedMax' : 'constrainedMin'];
+                width = constrainedWidth;
+
+                if (ownerContext.widthModel.calculatedFromShrinkWrap) {
+                    
+                    
+                    
+                    ownerContext.widthModel = widthModel;
+                } else {
+                    ownerContext.invalidate({ widthModel: widthModel });
+                }
+            }
+
+            ownerContext.setWidth(width, dirty);
+        }
+    }
+});
+
+
+Ext.define('Ext.layout.container.Auto', {
+
+    
+
+    alias: ['layout.auto', 'layout.autocontainer'],
+
+    extend: 'Ext.layout.container.Container',
+
+    
+
+    type: 'autocontainer',
+
+    childEls: [
+        'clearEl'
+    ],
+
+    renderTpl: [
+        '{%this.renderBody(out,values)%}',
+        
+        '<div id="{ownerId}-clearEl" class="', Ext.baseCSSPrefix, 'clear" role="presentation"></div>'
+    ],
+
+    
+
+    calculate: function(ownerContext) {
+        var me = this,
+            containerSize;
+
+        if (!ownerContext.hasDomProp('containerChildrenDone')) {
+            me.done = false;
+        } else {
+            
+            containerSize = me.getContainerSize(ownerContext);
+            if (!containerSize.gotAll) {
+                me.done = false;
+            }
+
+            me.calculateContentSize(ownerContext);
+        }
+    }
+});
+
+
+Ext.define('Ext.util.Filter', {
+
+    
+
+    
+    
+    
+    
+    
+    
+    anyMatch: false,
+    
+    
+    exactMatch: false,
+    
+    
+    caseSensitive: false,
+    
+    
+
+    
+    constructor: function(config) {
+        var me = this;
+        Ext.apply(me, config);
+        
+        
+        
+        me.filter = me.filter || me.filterFn;
+        
+        if (me.filter === undefined) {
+            if (me.property === undefined || me.value === undefined) {
+                
+                
+                
+                
+            } else {
+                me.filter = me.createFilterFn();
+            }
+            
+            me.filterFn = me.filter;
+        }
+    },
+    
+    
+    createFilterFn: function() {
+        var me       = this,
+            matcher  = me.createValueMatcher(),
+            property = me.property;
+        
+        return function(item) {
+            var value = me.getRoot.call(me, item)[property];
+            return matcher === null ? value === null : matcher.test(value);
+        };
+    },
+    
+    
+    getRoot: function(item) {
+        var root = this.root;
+        return root === undefined ? item : item[root];
+    },
+    
+    
+    createValueMatcher : function() {
+        var me            = this,
+            value         = me.value,
+            anyMatch      = me.anyMatch,
+            exactMatch    = me.exactMatch,
+            caseSensitive = me.caseSensitive,
+            escapeRe      = Ext.String.escapeRegex;
+            
+        if (value === null) {
+            return value;
+        }
+        
+        if (!value.exec) { 
+            value = String(value);
+
+            if (anyMatch === true) {
+                value = escapeRe(value);
+            } else {
+                value = '^' + escapeRe(value);
+                if (exactMatch === true) {
+                    value += '$';
+                }
+            }
+            value = new RegExp(value, caseSensitive ? '' : 'i');
+         }
+         
+         return value;
+    }
+});
+
+
+Ext.define('Ext.util.AbstractMixedCollection', {
+    requires: ['Ext.util.Filter'],
+
+    mixins: {
+        observable: 'Ext.util.Observable'
+    },
+
+    
+    isMixedCollection: true,
+
+    
+    generation: 0,
+
+    constructor: function(allowFunctions, keyFn) {
+        var me = this;
+
+        me.items = [];
+        me.map = {};
+        me.keys = [];
+        me.length = 0;
+
+            
+
+            
+
+            
+            
+
+        me.allowFunctions = allowFunctions === true;
+
+        if (keyFn) {
+            me.getKey = keyFn;
+        }
+
+        me.mixins.observable.constructor.call(me);
+    },
+
+    
+    allowFunctions : false,
+
+    
+    add : function(key, obj){
+        var me = this,
+            myObj = obj,
+            myKey = key,
+            old;
+
+        if (arguments.length == 1) {
+            myObj = myKey;
+            myKey = me.getKey(myObj);
+        }
+        if (typeof myKey != 'undefined' && myKey !== null) {
+            old = me.map[myKey];
+            if (typeof old != 'undefined') {
+                return me.replace(myKey, myObj);
+            }
+            me.map[myKey] = myObj;
+        }
+        me.generation++;
+        me.length++;
+        me.items.push(myObj);
+        me.keys.push(myKey);
+        if (me.hasListeners.add) {
+            me.fireEvent('add', me.length - 1, myObj, myKey);
+        }
+        return myObj;
+    },
+
+    
+    getKey : function(o){
+         return o.id;
+    },
+
+    
+    replace : function(key, o){
+        var me = this,
+            old,
+            index;
+
+        if (arguments.length == 1) {
+            o = arguments[0];
+            key = me.getKey(o);
+        }
+        old = me.map[key];
+        if (typeof key == 'undefined' || key === null || typeof old == 'undefined') {
+             return me.add(key, o);
+        }
+        me.generation++;
+        index = me.indexOfKey(key);
+        me.items[index] = o;
+        me.map[key] = o;
+        if (me.hasListeners.replace) {
+            me.fireEvent('replace', key, old, o);
+        }
+        return o;
+    },
+
+    
+    addAll : function(objs){
+        var me = this,
+            i = 0,
+            args,
+            len,
+            key;
+
+        if (arguments.length > 1 || Ext.isArray(objs)) {
+            args = arguments.length > 1 ? arguments : objs;
+            for (len = args.length; i < len; i++) {
+                me.add(args[i]);
+            }
+        } else {
+            for (key in objs) {
+                if (objs.hasOwnProperty(key)) {
+                    if (me.allowFunctions || typeof objs[key] != 'function') {
+                        me.add(key, objs[key]);
+                    }
+                }
+            }
+        }
+    },
+
+    
+    each : function(fn, scope){
+        var items = [].concat(this.items), 
+            i = 0,
+            len = items.length,
+            item;
+
+        for (; i < len; i++) {
+            item = items[i];
+            if (fn.call(scope || item, item, i, len) === false) {
+                break;
+            }
+        }
+    },
+
+    
+    eachKey : function(fn, scope){
+        var keys = this.keys,
+            items = this.items,
+            i = 0,
+            len = keys.length;
+
+        for (; i < len; i++) {
+            fn.call(scope || window, keys[i], items[i], i, len);
+        }
+    },
+
+    
+    findBy : function(fn, scope) {
+        var keys = this.keys,
+            items = this.items,
+            i = 0,
+            len = items.length;
+
+        for (; i < len; i++) {
+            if (fn.call(scope || window, items[i], keys[i])) {
+                return items[i];
+            }
+        }
+        return null;
+    },
+
+    find : function() {
+        if (Ext.isDefined(Ext.global.console)) {
+            Ext.global.console.warn('Ext.util.MixedCollection: find has been deprecated. Use findBy instead.');
+        }
+        return this.findBy.apply(this, arguments);
+    },
+
+    
+    insert : function(index, key, obj){
+        var me = this,
+            myKey = key,
+            myObj = obj;
+
+        if (arguments.length == 2) {
+            myObj = myKey;
+            myKey = me.getKey(myObj);
+        }
+        if (me.containsKey(myKey)) {
+            me.suspendEvents();
+            me.removeAtKey(myKey);
+            me.resumeEvents();
+        }
+        if (index >= me.length) {
+            return me.add(myKey, myObj);
+        }
+        me.generation++;
+        me.length++;
+        Ext.Array.splice(me.items, index, 0, myObj);
+        if (typeof myKey != 'undefined' && myKey !== null) {
+            me.map[myKey] = myObj;
+        }
+        Ext.Array.splice(me.keys, index, 0, myKey);
+        if (me.hasListeners.add) {
+            me.fireEvent('add', index, myObj, myKey);
+        }
+        return myObj;
+    },
+
+    
+    remove : function(o) {
+        this.generation++;
+        return this.removeAt(this.indexOf(o));
+    },
+
+    
+    removeAll : function(items) {
+        items = [].concat(items);
+        var i, iLen = items.length;
+        for (i = 0; i < iLen; i++) {
+            this.remove(items[i]);
+        }
+
+        return this;
+    },
+
+    
+    removeAt : function(index) {
+        var me = this,
+            o,
+            key;
+
+        if (index < me.length && index >= 0) {
+            me.length--;
+            o = me.items[index];
+            Ext.Array.erase(me.items, index, 1);
+            key = me.keys[index];
+            if (typeof key != 'undefined') {
+                delete me.map[key];
+            }
+            Ext.Array.erase(me.keys, index, 1);
+            if (me.hasListeners.remove) {
+                me.fireEvent('remove', o, key);
+            }
+            me.generation++;
+            return o;
+        }
+        return false;
+    },
+
+    
+    removeAtKey : function(key){
+        return this.removeAt(this.indexOfKey(key));
+    },
+
+    
+    getCount : function(){
+        return this.length;
+    },
+
+    
+    indexOf : function(o){
+        return Ext.Array.indexOf(this.items, o);
+    },
+
+    
+    indexOfKey : function(key){
+        return Ext.Array.indexOf(this.keys, key);
+    },
+
+    
+    get : function(key) {
+        var me = this,
+            mk = me.map[key],
+            item = mk !== undefined ? mk : (typeof key == 'number') ? me.items[key] : undefined;
+        return typeof item != 'function' || me.allowFunctions ? item : null; 
+    },
+
+    
+    getAt : function(index) {
+        return this.items[index];
+    },
+
+    
+    getByKey : function(key) {
+        return this.map[key];
+    },
+
+    
+    contains : function(o){
+        return typeof this.map[this.getKey(o)] != 'undefined';
+    },
+
+    
+    containsKey : function(key){
+        return typeof this.map[key] != 'undefined';
+    },
+
+    
+    clear : function(){
+        var me = this;
+
+        me.length = 0;
+        me.items = [];
+        me.keys = [];
+        me.map = {};
+        me.generation++;
+        if (me.hasListeners.clear) {
+            me.fireEvent('clear');
+        }
+    },
+
+    
+    first : function() {
+        return this.items[0];
+    },
+
+    
+    last : function() {
+        return this.items[this.length - 1];
+    },
+
+    
+    sum: function(property, root, start, end) {
+        var values = this.extractValues(property, root),
+            length = values.length,
+            sum    = 0,
+            i;
+
+        start = start || 0;
+        end   = (end || end === 0) ? end : length - 1;
+
+        for (i = start; i <= end; i++) {
+            sum += values[i];
+        }
+
+        return sum;
+    },
+
+    
+    collect: function(property, root, allowNull) {
+        var values = this.extractValues(property, root),
+            length = values.length,
+            hits   = {},
+            unique = [],
+            value, strValue, i;
+
+        for (i = 0; i < length; i++) {
+            value = values[i];
+            strValue = String(value);
+
+            if ((allowNull || !Ext.isEmpty(value)) && !hits[strValue]) {
+                hits[strValue] = true;
+                unique.push(value);
+            }
+        }
+
+        return unique;
+    },
+
+    
+    extractValues: function(property, root) {
+        var values = this.items;
+
+        if (root) {
+            values = Ext.Array.pluck(values, root);
+        }
+
+        return Ext.Array.pluck(values, property);
+    },
+
+    
+    getRange : function(start, end){
+        var me = this,
+            items = me.items,
+            range = [],
+            i;
+
+        if (items.length < 1) {
+            return range;
+        }
+
+        start = start || 0;
+        end = Math.min(typeof end == 'undefined' ? me.length - 1 : end, me.length - 1);
+        if (start <= end) {
+            for (i = start; i <= end; i++) {
+                range[range.length] = items[i];
+            }
+        } else {
+            for (i = start; i >= end; i--) {
+                range[range.length] = items[i];
+            }
+        }
+        return range;
+    },
+
+    
+    filter : function(property, value, anyMatch, caseSensitive) {
+        var filters = [],
+            filterFn;
+
+        
+        if (Ext.isString(property)) {
+            filters.push(new Ext.util.Filter({
+                property     : property,
+                value        : value,
+                anyMatch     : anyMatch,
+                caseSensitive: caseSensitive
+            }));
+        } else if (Ext.isArray(property) || property instanceof Ext.util.Filter) {
+            filters = filters.concat(property);
+        }
+
+        
+        
+        filterFn = function(record) {
+            var isMatch = true,
+                length = filters.length,
+                i,
+                filter,
+                fn,
+                scope;
+                
+
+            for (i = 0; i < length; i++) {
+                filter = filters[i];
+                fn     = filter.filterFn;
+                scope  = filter.scope;
+
+                isMatch = isMatch && fn.call(scope, record);
+            }
+
+            return isMatch;
+        };
+
+        return this.filterBy(filterFn);
+    },
+
+    
+    filterBy : function(fn, scope) {
+        var me = this,
+            newMC  = new this.self(),
+            keys   = me.keys,
+            items  = me.items,
+            length = items.length,
+            i;
+
+        newMC.getKey = me.getKey;
+
+        for (i = 0; i < length; i++) {
+            if (fn.call(scope || me, items[i], keys[i])) {
+                newMC.add(keys[i], items[i]);
+            }
+        }
+
+        return newMC;
+    },
+
+    
+    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 me = this,
+            keys = me.keys,
+            items = me.items,
+            i = start || 0,
+            len = items.length;
+
+        for (; i < len; i++) {
+            if (fn.call(scope || me, items[i], keys[i])) {
+                return i;
+            }
+        }
+        return -1;
+    },
+
+    
+    createValueMatcher : function(value, anyMatch, caseSensitive, exactMatch) {
+        if (!value.exec) { 
+            var er = Ext.String.escapeRegex;
+            value = String(value);
+
+            if (anyMatch === true) {
+                value = er(value);
+            } else {
+                value = '^' + er(value);
+                if (exactMatch === true) {
+                    value += '$';
+                }
+            }
+            value = new RegExp(value, caseSensitive ? '' : 'i');
+        }
+        return value;
+    },
+
+    
+    clone : function() {
+        var me = this,
+            copy = new this.self(),
+            keys = me.keys,
+            items = me.items,
+            i = 0,
+            len = items.length;
+
+        for(; i < len; i++){
+            copy.add(keys[i], items[i]);
+        }
+        copy.getKey = me.getKey;
+        return copy;
+    }
+});
+
+
+Ext.define('Ext.util.Sorter', {
+
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    direction: "ASC",
+    
+    constructor: function(config) {
+        var me = this;
+        
+        Ext.apply(me, config);
+        
+        
+        me.updateSortFunction();
+    },
+    
+    
+    createSortFunction: function(sorterFn) {
+        var me        = this,
+            property  = me.property,
+            direction = me.direction || "ASC",
+            modifier  = direction.toUpperCase() == "DESC" ? -1 : 1;
+        
+        
+        
+        return function(o1, o2) {
+            return modifier * sorterFn.call(me, o1, o2);
+        };
+    },
+    
+    
+    defaultSorterFn: function(o1, o2) {
+        var me = this,
+            transform = me.transform,
+            v1 = me.getRoot(o1)[me.property],
+            v2 = me.getRoot(o2)[me.property];
+            
+        if (transform) {
+            v1 = transform(v1);
+            v2 = transform(v2);
+        }
+
+        return v1 > v2 ? 1 : (v1 < v2 ? -1 : 0);
+    },
+    
+    
+    getRoot: function(item) {
+        return this.root === undefined ? item : item[this.root];
+    },
+    
+    
+    setDirection: function(direction) {
+        var me = this;
+        me.direction = direction ? direction.toUpperCase() : direction;
+        me.updateSortFunction();
+    },
+    
+    
+    toggle: function() {
+        var me = this;
+        me.direction = Ext.String.toggle(me.direction, "ASC", "DESC");
+        me.updateSortFunction();
+    },
+    
+    
+    updateSortFunction: function(fn) {
+        var me = this;
+        fn = fn || me.sorterFn || me.defaultSorterFn;
+        me.sort = me.createSortFunction(fn);
+    }
+});
+
+
+Ext.define("Ext.util.Sortable", {
+    
+    isSortable: true,
+
+    
+    defaultSortDirection: "ASC",
+
+    requires: [
+        'Ext.util.Sorter'
+    ],
+
+    
+
+    
+    initSortable: function() {
+        var me = this,
+            sorters = me.sorters;
+
+        
+        me.sorters = new Ext.util.AbstractMixedCollection(false, function(item) {
+            return item.id || item.property;
+        });
+
+        if (sorters) {
+            me.sorters.addAll(me.decodeSorters(sorters));
+        }
+    },
+
+    
+    sort: function(sorters, direction, where, doSort) {
+        var me = this,
+            sorter, sorterFn,
+            newSorters;
+
+        if (Ext.isArray(sorters)) {
+            doSort = where;
+            where = direction;
+            newSorters = sorters;
+        }
+        else if (Ext.isObject(sorters)) {
+            doSort = where;
+            where = direction;
+            newSorters = [sorters];
+        }
+        else if (Ext.isString(sorters)) {
+            sorter = me.sorters.get(sorters);
+
+            if (!sorter) {
+                sorter = {
+                    property : sorters,
+                    direction: direction
+                };
+                newSorters = [sorter];
+            }
+            else if (direction === undefined) {
+                sorter.toggle();
+            }
+            else {
+                sorter.setDirection(direction);
+            }
+        }
+
+        if (newSorters && newSorters.length) {
+            newSorters = me.decodeSorters(newSorters);
+            if (Ext.isString(where)) {
+                if (where === 'prepend') {
+                    sorters = me.sorters.clone().items;
+
+                    me.sorters.clear();
+                    me.sorters.addAll(newSorters);
+                    me.sorters.addAll(sorters);
+                }
+                else {
+                    me.sorters.addAll(newSorters);
+                }
+            }
+            else {
+                me.sorters.clear();
+                me.sorters.addAll(newSorters);
+            }
+        }
+
+        if (doSort !== false) {
+            me.onBeforeSort(newSorters);
+            
+            sorters = me.sorters.items;
+            if (sorters.length) {
+                
+                me.doSort(me.generateComparator());
+            }
+        }
+
+        return sorters;
+    },
+
+    
+    generateComparator: function() {
+        var sorters = this.sorters.getRange();
+        return sorters.length ? this.createComparator(sorters) : this.emptyComparator;
+    },
+    
+    createComparator: function(sorters) {
+        return function(r1, r2) {
+            var result = sorters[0].sort(r1, r2),
+                length = sorters.length,
+                i = 1;
+
+            
+            for (; i < length; i++) {
+                result = result || sorters[i].sort.call(this, r1, r2);
+            }
+            return result;
+        };
+    },
+    
+    emptyComparator: function(){
+        return 0;
+    },
+
+    onBeforeSort: Ext.emptyFn,
+
+    
+    decodeSorters: function(sorters) {
+        if (!Ext.isArray(sorters)) {
+            if (sorters === undefined) {
+                sorters = [];
+            } else {
+                sorters = [sorters];
+            }
+        }
+
+        var length = sorters.length,
+            Sorter = Ext.util.Sorter,
+            fields = this.model ? this.model.prototype.fields : null,
+            field,
+            config, i;
+
+        for (i = 0; i < length; i++) {
+            config = sorters[i];
+
+            if (!(config instanceof Sorter)) {
+                if (Ext.isString(config)) {
+                    config = {
+                        property: config
+                    };
+                }
+
+                Ext.applyIf(config, {
+                    root     : this.sortRoot,
+                    direction: "ASC"
+                });
+
+                
+                if (config.fn) {
+                    config.sorterFn = config.fn;
+                }
+
+                
+                if (typeof config == 'function') {
+                    config = {
+                        sorterFn: config
+                    };
+                }
+
+                
+                if (fields && !config.transform) {
+                    field = fields.get(config.property);
+                    config.transform = field ? field.sortType : undefined;
+                }
+                sorters[i] = new Ext.util.Sorter(config);
+            }
+        }
+
+        return sorters;
+    },
+
+    getSorters: function() {
+        return this.sorters.items;
+    },
+    
+    
+    getFirstSorter: function(){
+        var sorters = this.sorters.items,
+            len = sorters.length,
+            i = 0,
+            sorter;
+            
+        for (; i < len; ++i) {
+            sorter = sorters[i];
+            if (!sorter.isGrouper) {
+                return sorter;    
+            }
+        }
+        return null;
+    }
+});
+
+
+Ext.define('Ext.util.MixedCollection', {
+    extend: 'Ext.util.AbstractMixedCollection',
+    mixins: {
+        sortable: 'Ext.util.Sortable'
+    },
+
+    
+    constructor: function() {
+        var me = this;
+        me.callParent(arguments);
+        me.addEvents('sort');
+        me.mixins.sortable.initSortable.call(me);
+    },
+
+    doSort: function(sorterFn) {
+        this.sortBy(sorterFn);
+    },
+
+    
+    _sort : function(property, dir, fn){
+        var me = this,
+            i, len,
+            dsc   = String(dir).toUpperCase() == 'DESC' ? -1 : 1,
+
+            
+            c     = [],
+            keys  = me.keys,
+            items = me.items;
+
+        
+        fn = fn || function(a, b) {
+            return a - b;
+        };
+
+        
+        for(i = 0, len = items.length; i < len; i++){
+            c[c.length] = {
+                key  : keys[i],
+                value: items[i],
+                index: i
+            };
+        }
+
+        
+        Ext.Array.sort(c, function(a, b){
+            var v = fn(a[property], b[property]) * dsc;
+            if(v === 0){
+                v = (a.index < b.index ? -1 : 1);
+            }
+            return v;
+        });
+
+        
+        for(i = 0, len = c.length; i < len; i++){
+            items[i] = c[i].value;
+            keys[i]  = c[i].key;
+        }
+
+        me.fireEvent('sort', me);
+    },
+
+    
+    sortBy: function(sorterFn) {
+        var me     = this,
+            items  = me.items,
+            keys   = me.keys,
+            length = items.length,
+            temp   = [],
+            i;
+
+        
+        for (i = 0; i < length; i++) {
+            temp[i] = {
+                key  : keys[i],
+                value: items[i],
+                index: i
+            };
+        }
+
+        Ext.Array.sort(temp, function(a, b) {
+            var v = sorterFn(a.value, b.value);
+            if (v === 0) {
+                v = (a.index < b.index ? -1 : 1);
+            }
+
+            return v;
+        });
+
+        
+        for (i = 0; i < length; i++) {
+            items[i] = temp[i].value;
+            keys[i]  = temp[i].key;
+        }
+
+        me.fireEvent('sort', me, items, keys);
+    },
+
+    
+    findInsertionIndex: function(newItem, sorterFn) {
+        var me    = this,
+            items = me.items,
+            start = 0,
+            end   = items.length - 1,
+            middle,
+            comparison;
+
+        if (!sorterFn) {
+            sorterFn = me.generateComparator();
+        }
+        while (start <= end) {
+            middle = (start + end) >> 1;
+            comparison = sorterFn(newItem, items[middle]);
+            if (comparison >= 0) {
+                start = middle + 1;
+            } else if (comparison < 0) {
+                end = middle - 1;
+            }
+        }
+        return start;
+    },
+
+    
+    reorder: function(mapping) {
+        var me = this,
+            items = me.items,
+            index = 0,
+            length = items.length,
+            order = [],
+            remaining = [],
+            oldIndex;
+
+        me.suspendEvents();
+
+        
+        for (oldIndex in mapping) {
+            order[mapping[oldIndex]] = items[oldIndex];
+        }
+
+        for (index = 0; index < length; index++) {
+            if (mapping[index] == undefined) {
+                remaining.push(items[index]);
+            }
+        }
+
+        for (index = 0; index < length; index++) {
+            if (order[index] == undefined) {
+                order[index] = remaining.shift();
+            }
+        }
+
+        me.clear();
+        me.addAll(order);
+
+        me.resumeEvents();
+        me.fireEvent('sort', me);
+    },
+
+    
+    sortByKey : function(dir, fn){
+        this._sort('key', dir, fn || function(a, b){
+            var v1 = String(a).toUpperCase(), v2 = String(b).toUpperCase();
+            return v1 > v2 ? 1 : (v1 < v2 ? -1 : 0);
+        });
+    }
+});
+
+
+Ext.define('Ext.ZIndexManager', {
+    alternateClassName: 'Ext.WindowGroup',
+
+    statics: {
+        zBase : 9000
+    },
+
+    constructor: function(container) {
+        var me = this;
+
+        me.list = {};
+        me.zIndexStack = [];
+        me.front = null;
+
+        if (container) {
+
+            
+            if (container.isContainer) {
+                container.on('resize', me._onContainerResize, me);
+                me.zseed = Ext.Number.from(me.rendered ? container.getEl().getStyle('zIndex') : undefined, me.getNextZSeed());
+                
+                me.targetEl = container.getTargetEl();
+                me.container = container;
+            }
+            
+            else {
+                Ext.EventManager.onWindowResize(me._onContainerResize, me);
+                me.zseed = me.getNextZSeed();
+                me.targetEl = Ext.get(container);
+            }
+        }
+        
+        
+        else {
+            Ext.EventManager.onWindowResize(me._onContainerResize, me);
+            me.zseed = me.getNextZSeed();
+            Ext.onDocumentReady(function() {
+                me.targetEl = Ext.getBody();
+            });
+        }
+    },
+
+    getNextZSeed: function() {
+        return (Ext.ZIndexManager.zBase += 10000);
+    },
+
+    setBase: function(baseZIndex) {
+        this.zseed = baseZIndex;
+        var result = this.assignZIndices();
+        this._activateLast();
+        return result;
+    },
+
+    
+    assignZIndices: function() {
+        var a = this.zIndexStack,
+            len = a.length,
+            i = 0,
+            zIndex = this.zseed,
+            comp;
+
+        for (; i < len; i++) {
+            comp = a[i];
+            if (comp && !comp.hidden) {
+
+                
+                
+                
+                
+                
+                
+                
+                zIndex = comp.setZIndex(zIndex);
+            }
+        }
+
+        
+        this._activateLast();
+        return zIndex;
+    },
+
+    
+    _setActiveChild: function(comp, oldFront) {
+        var front = this.front;
+        if (comp !== front) {
+
+            if (front && !front.destroying) {
+                front.setActive(false, comp);
+            }
+            this.front = comp;
+            if (comp && comp != oldFront) {
+                comp.setActive(true);
+                if (comp.modal) {
+                    this._showModalMask(comp);
+                }
+            }
+        }
+    },
+    
+    onComponentHide: function(comp){
+        comp.setActive(false);
+        this._activateLast();
+    },
+
+    
+    _activateLast: function() {
+        var me = this,
+            stack = me.zIndexStack,
+            i = stack.length - 1,
+            oldFront = me.front,
+            comp;
+
+        
+        me.front = undefined;
+
+        
+        
+        
+        for (; i >= 0 && stack[i].hidden; --i);
+        if ((comp = stack[i])) {
+            me._setActiveChild(comp, oldFront);
+            if (comp.modal) {
+                return;
+            }
+        }
+
+        
+        
+        for (; i >= 0; --i) {
+            comp = stack[i];
+            
+            if (comp.isVisible() && comp.modal) {
+                me._showModalMask(comp);
+                return;
+            }
+        }
+
+        
+        
+        me._hideModalMask();
+    },
+
+    _showModalMask: function(comp) {
+        var me = this,
+            zIndex = comp.el.getStyle('zIndex') - 4,
+            maskTarget = comp.floatParent ? comp.floatParent.getTargetEl() : comp.container,
+            viewSize = maskTarget.getBox();
+
+        if (maskTarget.dom === document.body) {
+            viewSize.height = Math.max(document.body.scrollHeight, Ext.dom.Element.getDocumentHeight());
+            viewSize.width = Math.max(document.body.scrollWidth, viewSize.width);
+        }
+        if (!me.mask) {
+            me.mask = Ext.getBody().createChild({
+                cls: Ext.baseCSSPrefix + 'mask'
+            });
+            me.mask.setVisibilityMode(Ext.Element.DISPLAY);
+            me.mask.on('click', me._onMaskClick, me);
+        }
+        me.mask.maskTarget = maskTarget;
+        maskTarget.addCls(Ext.baseCSSPrefix + 'body-masked');
+        me.mask.setStyle('zIndex', zIndex);
+
+        
+        
+        me.mask.show();
+        me.mask.setBox(viewSize);
+    },
+
+    _hideModalMask: function() {
+        var mask = this.mask;
+        if (mask && mask.isVisible()) {
+            mask.maskTarget.removeCls(Ext.baseCSSPrefix + 'body-masked');
+            mask.maskTarget = undefined;
+            mask.hide();
+        }
+    },
+
+    _onMaskClick: function() {
+        if (this.front) {
+            this.front.focus();
+        }
+    },
+
+    _onContainerResize: function() {
+        var mask = this.mask,
+            maskTarget,
+            viewSize;
+
+        if (mask && mask.isVisible()) {
+
+            
+            
+            mask.hide();
+            maskTarget = mask.maskTarget;
+
+            if (maskTarget.dom === document.body) {
+                viewSize = {
+                    height: Math.max(document.body.scrollHeight, Ext.dom.Element.getDocumentHeight()),
+                    width: Math.max(document.body.scrollWidth, document.documentElement.clientWidth)
+                };
+            } else {
+                viewSize = maskTarget.getViewSize(true);
+            }
+            mask.setSize(viewSize);
+            mask.show();
+        }
+    },
+
+    
+    register : function(comp) {
+        var me = this;
+        
+        if (comp.zIndexManager) {
+            comp.zIndexManager.unregister(comp);
+        }
+        comp.zIndexManager = me;
+
+        me.list[comp.id] = comp;
+        me.zIndexStack.push(comp);
+        comp.on('hide', me.onComponentHide, me);
+    },
+
+    
+    unregister : function(comp) {
+        var me = this,
+            list = me.list;
+        
+        delete comp.zIndexManager;
+        if (list && list[comp.id]) {
+            delete list[comp.id];
+            comp.un('hide', me.onComponentHide);
+            Ext.Array.remove(me.zIndexStack, comp);
+
+            
+            me._activateLast();
+        }
+    },
+
+    
+    get : function(id) {
+        return id.isComponent ? id : this.list[id];
+    },
+
+   
+    bringToFront : function(comp) {
+        var me = this,
+            result = false,
+            zIndexStack = me.zIndexStack;
+        
+        comp = me.get(comp);
+        if (comp !== me.front) {
+            Ext.Array.remove(zIndexStack, comp);
+            if (comp.preventBringToFront) {
+                
+                zIndexStack.unshift(comp);
+            } else {
+                
+                zIndexStack.push(comp);
+            }
+
+            me.assignZIndices();
+            result = true;
+            this.front = comp;
+        }
+        if (result && comp.modal) {
+            me._showModalMask(comp);
+        }
+        return result;
+    },
+
+    
+    sendToBack : function(comp) {
+        var me = this;
+        
+        comp = me.get(comp);
+        Ext.Array.remove(me.zIndexStack, comp);
+        me.zIndexStack.unshift(comp);
+        me.assignZIndices();
+        this._activateLast();
+        return comp;
+    },
+
+    
+    hideAll : function() {
+        var list = this.list,
+            item,
+            id;
+            
+        for (id in list) {
+            if (list.hasOwnProperty(id)) {
+                item = list[id];
+                if (item.isComponent && item.isVisible()) {
+                    item.hide();
+                }
+            }
+        }
+    },
+
+    
+    hide: function() {
+        var me = this,
+            mask = me.mask,
+            i = 0,
+            stack = me.zIndexStack,
+            len = stack.length,
+            comp;
+
+        me.tempHidden = me.tempHidden||[];
+        for (; i < len; i++) {
+            comp = stack[i];
+            if (comp.isVisible()) {
+                me.tempHidden.push(comp);
+                comp.el.hide();
+            }
+        }
+        
+        
+        if (mask) {
+            mask.hide();
+        }
+    },
+
+    
+    show: function() {
+        var me = this,
+            mask = me.mask,
+            i = 0,
+            tempHidden = me.tempHidden,
+            len = tempHidden ? tempHidden.length : 0,
+            comp;
+
+        for (; i < len; i++) {
+            comp = tempHidden[i];
+            comp.el.show();
+            comp.setPosition(comp.x, comp.y);
+        }
+        me.tempHidden.length = 0;
+
+        
+        if (mask) {
+            mask.show();
+            mask.alignTo(mask.maskTarget, 'tl-tl');
+        }
+    },
+
+    
+    getActive : function() {
+        return this.front;
+    },
+
+    
+    getBy : function(fn, scope) {
+        var r = [],
+            i = 0,
+            stack = this.zIndexStack,
+            len = stack.length,
+            comp;
+
+        for (; i < len; i++) {
+            comp = stack[i];
+            if (fn.call(scope||comp, comp) !== false) {
+                r.push(comp);
+            }
+        }
+        return r;
+    },
+
+    
+    each : function(fn, scope) {
+        var list = this.list,
+            id,
+            comp;
+            
+        for (id in list) {
+            if (list.hasOwnProperty(id)) {
+                comp = list[id];
+                if (comp.isComponent && fn.call(scope || comp, comp) === false) {
+                    return;
+                }
+            }
+        }
+    },
+
+    
+    eachBottomUp: function (fn, scope) {
+        var stack = this.zIndexStack,
+            i = 0,
+            len = stack.length,
+            comp;
+
+        for (; i < len; i++) {
+            comp = stack[i];
+            if (comp.isComponent && fn.call(scope || comp, comp) === false) {
+                return;
+            }
+        }
+    },
+
+    
+    eachTopDown: function (fn, scope) {
+        var stack = this.zIndexStack,
+            i = stack.length,
+            comp;
+
+        for (; i-- > 0; ) {
+            comp = stack[i];
+            if (comp.isComponent && fn.call(scope || comp, comp) === false) {
+                return;
+            }
+        }
+    },
+
+    destroy: function() {
+        var me   = this,
+            list = me.list,
+            comp,
+            id;
+
+        for (id in list) {
+            if (list.hasOwnProperty(id)) {
+                comp = list[id];
+
+                if (comp.isComponent) {
+                    comp.destroy();
+                }
+            }
+        }
+
+        delete me.zIndexStack;
+        delete me.list;
+        delete me.container;
+        delete me.targetEl;
+    }
+}, function() {
+    
+    Ext.WindowManager = Ext.WindowMgr = new this();
+});
+
+
+Ext.define('Ext.container.AbstractContainer', {
+
+    
+
+    extend: 'Ext.Component',
+
+    requires: [
+        'Ext.util.MixedCollection',
+        'Ext.layout.container.Auto',
+        'Ext.ZIndexManager'
+    ],
+
+    
+
+    renderTpl: '{%this.renderContainer(out,values)%}',
+
+    
+
+    
+
+    
+
+    
+
+    
+    suspendLayout : false,
+
+    
+    autoDestroy : true,
+
+     
+    defaultType: 'panel',
+    
+    
+    detachOnRemove: true,
+
+    
+    isContainer : true,
+
+    
+    layoutCounter : 0,
+
+    baseCls: Ext.baseCSSPrefix + 'container',
+
+    
+    bubbleEvents: ['add', 'remove'],
+
+    defaultLayoutType: 'auto',
+
+    
+    initComponent : function(){
+        var me = this;
+        me.addEvents(
+            
+            'afterlayout',
+            
+            'beforeadd',
+            
+            'beforeremove',
+            
+            'add',
+            
+            'remove'
+        );
+
+        me.callParent();
+
+        me.getLayout();
+        me.initItems();
+    },
+
+    
+    initItems : function() {
+        var me = this,
+            items = me.items;
+
+        
+        me.items = new Ext.util.AbstractMixedCollection(false, me.getComponentId);
+
+        if (items) {
+            if (!Ext.isArray(items)) {
+                items = [items];
+            }
+
+            me.add(items);
+        }
+    },
+
+    
+    getFocusEl: function() {
+        return this.getTargetEl();
+    },
+
+    finishRenderChildren: function () {
+        this.callParent();
+
+        var layout = this.getLayout();
+
+        if (layout) {
+            layout.finishRender();
+        }
+    },
+
+    beforeRender: function () {
+        var me = this,
+            layout = me.getLayout();
+
+        me.callParent();
+
+        if (!layout.initialized) {
+            layout.initLayout();
+        }
+    },
+    
+    setupRenderTpl: function (renderTpl) {
+        var layout = this.getLayout();
+
+        this.callParent(arguments);
+
+        layout.setupRenderTpl(renderTpl);
+    },
+
+    
+    setLayout : function(layout) {
+        var currentLayout = this.layout;
+
+        if (currentLayout && currentLayout.isLayout && currentLayout != layout) {
+            currentLayout.setOwner(null);
+        }
+
+        this.layout = layout;
+        layout.setOwner(this);
+    },
+
+    
+    getLayout : function() {
+        var me = this;
+        if (!me.layout || !me.layout.isLayout) {
+            
+            me.setLayout(Ext.layout.Layout.create(me.layout, me.self.prototype.layout || 'autocontainer'));
+        }
+
+        return me.layout;
+    },
+
+    
+    doLayout : function() {
+        this.updateLayout();
+        return this;
+    },
+
+    
+    afterLayout : function(layout) {
+        var me = this;
+        ++me.layoutCounter;
+        if (me.hasListeners.afterlayout) {
+            me.fireEvent('afterlayout', me, layout);
+        }
+    },
+
+    
+    prepareItems : function(items, applyDefaults) {
+        
+        
+        if (Ext.isArray(items)) {
+            items = items.slice();
+        } else {
+            items = [items];
+        }
+
+        
+        var me = this,
+            i = 0,
+            len = items.length,
+            item;
+
+        for (; i < len; i++) {
+            item = items[i];
+            if (item == null) {
+                Ext.Array.erase(items, i, 1);
+                --i;
+                --len;
+            } else {
+                if (applyDefaults) {
+                    item = this.applyDefaults(item);
+                }
+
+                
+                item.isContained = me;
+                items[i] = me.lookupComponent(item);
+                delete item.isContained;
+            }
+        }
+
+        return items;
+    },
+
+    
+    applyDefaults : function(config) {
+        var defaults = this.defaults;
+
+        if (defaults) {
+            if (Ext.isFunction(defaults)) {
+                defaults = defaults.call(this, config);
+            }
+
+            if (Ext.isString(config)) {
+                config = Ext.ComponentManager.get(config);
+            }
+            Ext.applyIf(config, defaults);
+        }
+        return config;
+    },
+
+    
+    lookupComponent : function(comp) {
+        return (typeof comp == 'string') ? Ext.ComponentManager.get(comp)
+                                         : Ext.ComponentManager.create(comp, this.defaultType);
+    },
+
+    
+    getComponentId : function(comp) {
+        return comp.getItemId();
+    },
+
+    
+    add : function() {
+        var me = this,
+            args = Ext.Array.slice(arguments),
+            index = (typeof args[0] == 'number') ? args.shift() : -1,
+            layout = me.getLayout(),
+            addingArray, items, i, length, item, pos, ret;
+
+        if (args.length == 1 && Ext.isArray(args[0])) {
+            items = args[0];
+            addingArray = true;
+        } else {
+            items = args;
+        }
+
+        ret = items = me.prepareItems(items, true);
+        length = items.length;
+
+        if (me.rendered) {
+            Ext.suspendLayouts(); 
+        }
+
+        if (!addingArray && length == 1) { 
+            ret = items[0];
+        }
+
+        
+        for (i = 0; i < length; i++) {
+            item = items[i];
+
+            pos = (index < 0) ? me.items.length : (index + i);
+
+            
+            if (item.floating) {
+                me.floatingItems = me.floatingItems || new Ext.util.MixedCollection();
+                me.floatingItems.add(item);
+                item.onAdded(me, pos);
+            } else if ((!me.hasListeners.beforeadd || me.fireEvent('beforeadd', me, item, pos) !== false) && me.onBeforeAdd(item) !== false) {
+                me.items.insert(pos, item);
+                item.onAdded(me, pos);
+                me.onAdd(item, pos);
+                layout.onAdd(item, pos);
+
+                if (me.hasListeners.add) {
+                    me.fireEvent('add', me, item, pos);
+                }
+            }
+        }
+
+        
+        me.updateLayout();
+        if (me.rendered) {
+            Ext.resumeLayouts(true);
+        }
+
+        return ret;
+    },
+
+    
+    onAdd : Ext.emptyFn,
+
+    
+    onRemove : Ext.emptyFn,
+
+    
+    insert : function(index, comp) {
+        return this.add(index, comp);
+    },
+
+    
+    move : function(fromIdx, toIdx) {
+        var items = this.items,
+            item;
+        item = items.removeAt(fromIdx);
+        if (item === false) {
+            return false;
+        }
+        items.insert(toIdx, item);
+        this.doLayout();
+        return item;
+    },
+
+    
+    onBeforeAdd : function(item) {
+        var me = this,
+            border = item.border;
+
+        
+        if (item.ownerCt && item.ownerCt !== me) {
+            item.ownerCt.remove(item, false);
+        }
+
+        if (me.border === false || me.border === 0) {
+            
+            item.border = Ext.isDefined(border) && border !== false && border !== 0;
+        }
+    },
+
+    
+    remove : function(comp, autoDestroy) {
+        var me = this,
+            c = me.getComponent(comp);
+
+        if (c && (!me.hasListeners.beforeremove || me.fireEvent('beforeremove', me, c) !== false)) {
+            me.doRemove(c, autoDestroy);
+            if (me.hasListeners.remove) {
+                me.fireEvent('remove', me, c);
+            }
+
+            if (!me.destroying) {
+                me.doLayout();
+            }
+        }
+
+        return c;
+    },
+
+    
+    doRemove : function(component, autoDestroy) {
+        var me = this,
+            layout = me.layout,
+            hasLayout = layout && me.rendered,
+            destroying = autoDestroy === true || (autoDestroy !== false && me.autoDestroy);
+
+        autoDestroy = autoDestroy === true || (autoDestroy !== false && me.autoDestroy);
+        me.items.remove(component);
+
+        
+        if (hasLayout) {
+            
+            if (layout.running) {
+                Ext.AbstractComponent.cancelLayout(component, destroying);
+            }
+            layout.onRemove(component, destroying);
+        }
+
+        component.onRemoved(destroying);
+
+        me.onRemove(component, destroying);
+
+        
+        if (destroying) {
+            component.destroy();
+        }
+        
+        else {
+            if (hasLayout) {
+                layout.afterRemove(component);       
+            }
+            if (me.detachOnRemove && component.rendered) {
+                Ext.getDetachedBody().appendChild(component.getEl());
+            }
+        }
+    },
+
+    
+    removeAll : function(autoDestroy) {
+        var me = this,
+            removeItems = me.items.items.slice(),
+            items = [],
+            i = 0,
+            len = removeItems.length,
+            item;
+
+        
+        me.suspendLayouts();
+        for (; i < len; i++) {
+            item = removeItems[i];
+            me.remove(item, autoDestroy);
+
+            if (item.ownerCt !== me) {
+                items.push(item);
+            }
+        }
+
+        
+        me.resumeLayouts(!!len);
+        return items;
+    },
+
+    
+    
+    
+    
+    
+    
+    
+    
+    getRefItems : function(deep) {
+        var me = this,
+            items = me.items.items,
+            len = items.length,
+            i = 0,
+            item,
+            result = [];
+
+        for (; i < len; i++) {
+            item = items[i];
+            result.push(item);
+            if (deep && item.getRefItems) {
+                result.push.apply(result, item.getRefItems(true));
+            }
+        }
+
+        
+        if (me.floatingItems) {
+            result.push.apply(result, me.floatingItems.items);
+        }
+
+        return result;
+    },
+
+    
+    cascade : function(fn, scope, origArgs){
+        var me = this,
+            cs = me.items ? me.items.items : [],
+            len = cs.length,
+            i = 0,
+            c,
+            args = origArgs ? origArgs.concat(me) : [me],
+            componentIndex = args.length - 1;
+
+        if (fn.apply(scope || me, args) !== false) {
+            for (; i < len; i++){
+                c = cs[i];
+                if (c.cascade) {
+                    c.cascade(fn, scope, origArgs);
+                } else {
+                    args[componentIndex] = c;
+                    fn.apply(scope || cs, args);
+                }
+            }
+        }
+        return this;
+    },
+
+    
+    isAncestor: function(possibleDescendant) {
+        while (possibleDescendant) {
+            if (possibleDescendant.ownerCt === this) {
+                return true;
+            }
+            possibleDescendant = possibleDescendant.ownerCt;
+        }
+    },
+
+    
+    getComponent : function(comp) {
+        if (Ext.isObject(comp)) {
+            comp = comp.getItemId();
+        }
+
+        return this.items.get(comp);
+    },
+
+    
+    query : function(selector) {
+        selector = selector || '*';
+        return Ext.ComponentQuery.query(selector, this);
+    },
+    
+    
+    queryBy: function(fn, scope) {
+        var out = [],
+            items = this.getRefItems(true),
+            i = 0,
+            len = items.length,
+            item;
+            
+        for (; i < len; ++i) {
+            item = items[i];
+            if (fn.call(scope || item, item) !== false) {
+                out.push(item);
+            }
+        }
+        return out;
+    },
+    
+    
+    queryById: function(id){
+        return this.down('#' + id);
+    },
+
+    
+    child : function(selector) {
+        selector = selector || '';
+        return this.query('> ' + selector)[0] || null;
+    },
+
+    nextChild: function(child, selector) {
+        var me = this,
+            result,
+            childIndex = me.items.indexOf(child);
+
+        if (childIndex !== -1) {
+            result = selector ? Ext.ComponentQuery(selector, me.items.items.slice(childIndex + 1)) : me.items.getAt(childIndex + 1);
+            if (!result && me.ownerCt) {
+                result = me.ownerCt.nextChild(me, selector);
+            }
+        }
+        return result;
+    },
+
+    prevChild: function(child, selector) {
+        var me = this,
+            result,
+            childIndex = me.items.indexOf(child);
+
+        if (childIndex !== -1) {
+            result = selector ? Ext.ComponentQuery(selector, me.items.items.slice(childIndex + 1)) : me.items.getAt(childIndex + 1);
+            if (!result && me.ownerCt) {
+                result = me.ownerCt.nextChild(me, selector);
+            }
+        }
+        return result;
+    },
+
+    
+    down : function(selector) {
+        return this.query(selector)[0] || null;
+    },
+
+    
+    
+    
+    enable: function() {
+        this.callParent(arguments);
+
+        var itemsToDisable = this.getChildItemsToDisable(),
+            length         = itemsToDisable.length,
+            item, i;
+
+        for (i = 0; i < length; i++) {
+            item = itemsToDisable[i];
+
+            if (item.resetDisable) {
+                item.enable();
+            }
+        }
+
+        return this;
+    },
+
+    
+    
+    
+    disable: function() {
+        this.callParent(arguments);
+
+        var itemsToDisable = this.getChildItemsToDisable(),
+            length         = itemsToDisable.length,
+            item, i;
+
+        for (i = 0; i < length; i++) {
+            item = itemsToDisable[i];
+
+            if (item.resetDisable !== false && !item.disabled) {
+                item.disable();
+                item.resetDisable = true;
+            }
+        }
+
+        return this;
+    },
+    
+    
+    getChildItemsToDisable: function(){
+        return this.query('[isFormField],button');
+    },
+
+    
+    beforeLayout: function() {
+        return true;
+    },
+
+    
+    beforeDestroy : function() {
+        var me = this,
+            items = me.items,
+            c;
+
+        if (items) {
+            while ((c = items.first())) {
+                me.doRemove(c, true);
+            }
+        }
+
+        Ext.destroy(
+            me.layout
+        );
+        me.callParent();
+    }
+});
+
+
+Ext.define('Ext.container.Container', {
+    extend: 'Ext.container.AbstractContainer',
+    alias: 'widget.container',
+    alternateClassName: 'Ext.Container',
+
+    
+    fireHierarchyEvent: function (ename) {
+        this.hierarchyEventSource.fireEvent(ename, this);
+    },
+
+    
+    afterHide: function() {
+        this.callParent(arguments);
+        this.fireHierarchyEvent('hide');
+    },
+    
+    afterShow: function(){
+        this.callParent(arguments);
+        this.fireHierarchyEvent('show');
+    },
+
+    onAdded: function() {
+        this.callParent(arguments);
+        if (this.hierarchyEventSource.hasListeners.added) {
+            this.fireHierarchyEvent('added');
+        }
+    },
+
+    
+    getChildByElement: function(el, deep) {
+        var item,
+            itemEl,
+            i = 0,
+            it = this.getRefItems(),
+            ln = it.length;
+
+        el = Ext.getDom(el);
+        for (; i < ln; i++) {
+            item = it[i];
+            itemEl = item.getEl();
+            if (itemEl && ((itemEl.dom === el) || itemEl.contains(el))) {
+                return (deep && item.getChildByElement) ? item.getChildByElement(el, deep) : item;
+            }
+        }
+        return null;
+    }
+}, function () {
+    
+    this.hierarchyEventSource = this.prototype.hierarchyEventSource = new Ext.util.Observable({ events: {
+        hide: true,
+        show: true,
+        collapse: true,
+        expand: true,
+        added: true
+    }});
+});
+
+
+Ext.define('Ext.Editor', {
+
+    
+
+    extend: 'Ext.container.Container',
+
+    alias: 'widget.editor',
+
+    requires: ['Ext.layout.container.Editor'],
+
+    
+
+   layout: 'editor',
+
+    
+
+    
+    allowBlur: true,
+
+    
+
+    
+    revertInvalid: true,
+
+    
+
+    
+
+    
+    value : '',
+
+    
+    alignment: 'c-c?',
+
+    
+    offsets: [0, 0],
+
+    
+    shadow : 'frame',
+
+    
+    constrain : false,
+
+    
+    swallowKeys : true,
+
+    
+    completeOnEnter : true,
+
+    
+    cancelOnEsc : true,
+
+    
+    updateEl : false,
+
+    
+
+    
+    hidden: true,
+    baseCls: Ext.baseCSSPrefix + 'editor',
+
+    initComponent : function() {
+        var me = this,
+            field = me.field = Ext.ComponentManager.create(me.field, 'textfield');
+
+        Ext.apply(field, {
+            inEditor: true,
+            msgTarget: field.msgTarget == 'title' ? 'title' :  'qtip'
+        });
+        me.mon(field, {
+            scope: me,
+            blur: {
+                fn: me.onFieldBlur,
+                
+                delay: 1
+            },
+            specialkey: me.onSpecialKey
+        });
+
+        if (field.grow) {
+            me.mon(field, 'autosize', me.onFieldAutosize,  me, {delay: 1});
+        }
+        me.floating = {
+            constrain: me.constrain
+        };
+        me.items = field;
+
+        me.callParent(arguments);
+
+        me.addEvents(
+            
+            'beforestartedit',
+
+            
+            'startedit',
+
+            
+            'beforecomplete',
+            
+            'complete',
+            
+            'canceledit',
+            
+            'specialkey'
+        );
+    },
+
+    
+    onFieldAutosize: function(){
+        this.updateLayout();
+    },
+
+    
+    afterRender : function(ct, position) {
+        var me = this,
+            field = me.field,
+            inputEl = field.inputEl;
+
+        me.callParent(arguments);
+
+        
+        if (inputEl) {
+            inputEl.dom.name = '';
+            if (me.swallowKeys) {
+                inputEl.swallowEvent([
+                    'keypress', 
+                    'keydown'   
+                ]);
+            }
+        }
+    },
+
+    
+    onSpecialKey : function(field, event) {
+        var me = this,
+            key = event.getKey(),
+            complete = me.completeOnEnter && key == event.ENTER,
+            cancel = me.cancelOnEsc && key == event.ESC;
+
+        if (complete || cancel) {
+            event.stopEvent();
+            
+            
+            Ext.defer(function() {
+                if (complete) {
+                    me.completeEdit();
+                } else {
+                    me.cancelEdit();
+                }
+                if (field.triggerBlur) {
+                    field.triggerBlur(event);
+                }
+            }, 10);
+        }
+
+        me.fireEvent('specialkey', me, field, event);
+    },
+
+    
+    startEdit : function(el, value) {
+        var me = this,
+            field = me.field;
+
+        me.completeEdit();
+        me.boundEl = Ext.get(el);
+        value = Ext.isDefined(value) ? value : Ext.String.trim(me.boundEl.dom.innerText || me.boundEl.dom.innerHTML);
+
+        if (!me.rendered) {
+            me.render(me.parentEl || document.body);
+        }
+
+        if (me.fireEvent('beforestartedit', me, me.boundEl, value) !== false) {
+            me.startValue = value;
+            me.show();
+            
+            field.suspendEvents();
+            field.reset();
+            field.setValue(value);
+            field.resumeEvents();
+            me.realign(true);
+            field.focus(false, 10);
+            if (field.autoSize) {
+                field.autoSize();
+            }
+            me.editing = true;
+        }
+    },
+
+    
+    realign : function(autoSize) {
+        var me = this;
+        if (autoSize === true) {
+            me.updateLayout();
+        }
+        me.alignTo(me.boundEl, me.alignment, me.offsets);
+    },
+
+    
+    completeEdit : function(remainVisible) {
+        var me = this,
+            field = me.field,
+            value;
+
+        if (!me.editing) {
+            return;
+        }
+
+        
+        if (field.assertValue) {
+            field.assertValue();
+        }
+
+        value = me.getValue();
+        if (!field.isValid()) {
+            if (me.revertInvalid !== false) {
+                me.cancelEdit(remainVisible);
+            }
+            return;
+        }
+
+        if (String(value) === String(me.startValue) && me.ignoreNoChange) {
+            me.hideEdit(remainVisible);
+            return;
+        }
+
+        if (me.fireEvent('beforecomplete', me, value, me.startValue) !== false) {
+            
+            value = me.getValue();
+            if (me.updateEl && me.boundEl) {
+                me.boundEl.update(value);
+            }
+            me.hideEdit(remainVisible);
+            me.fireEvent('complete', me, value, me.startValue);
+        }
+    },
+
+    
+    onShow : function() {
+        var me = this;
+
+        me.callParent(arguments);
+        if (me.hideEl !== false) {
+            me.boundEl.hide();
+        }
+        me.fireEvent('startedit', me, me.boundEl, me.startValue);
+    },
+
+    
+    cancelEdit : function(remainVisible) {
+        var me = this,
+            startValue = me.startValue,
+            field = me.field,
+            value;
+
+        if (me.editing) {
+            value = me.getValue();
+            
+            field.suspendEvents();
+            me.setValue(startValue);
+            field.resumeEvents();
+            me.hideEdit(remainVisible);
+            me.fireEvent('canceledit', me, value, startValue);
+        }
+    },
+
+    
+    hideEdit: function(remainVisible) {
+        if (remainVisible !== true) {
+            this.editing = false;
+            this.hide();
+        }
+    },
+
+    
+    onFieldBlur : function(field, e) {
+        var me = this,
+            target;
+
+        
+        if(me.allowBlur === true && me.editing && me.selectSameEditor !== true) {
+            me.completeEdit();
+        }
+
+        
+        if (e && Ext.fly(target = e.getTarget()).focusable()) {
+            target.focus();
+        }
+    },
+
+    
+    onHide : function() {
+        var me = this,
+            field = me.field;
+
+        if (me.editing) {
+            me.completeEdit();
+            return;
+        }
+        if (field.hasFocus) {
+            field.blur();
+        }
+        if (field.collapse) {
+            field.collapse();
+        }
+
+        
+        if (me.hideEl !== false) {
+            me.boundEl.show();
+        }
+        me.callParent(arguments);
+    },
+
+    
+    setValue : function(value) {
+        this.field.setValue(value);
+    },
+
+    
+    getValue : function() {
+        return this.field.getValue();
+    },
+
+    beforeDestroy : function() {
+        var me = this;
+
+        Ext.destroy(me.field);
+        delete me.field;
+        delete me.parentEl;
+        delete me.boundEl;
+
+        me.callParent(arguments);
+    }
+});
+
+
+Ext.define('Ext.util.KeyMap', {
+    alternateClassName: 'Ext.KeyMap',
+
+    
+
+    
+
+    
+
+    
+
+    
+    eventName: 'keydown',
+
+    constructor: function(config) {
+        var me = this;
+
+        
+        
+        if ((arguments.length !== 1) || (typeof config === 'string') || config.dom || config.tagName || config === document || config.isComponent) {
+            me.legacyConstructor.apply(me, arguments);
+            return;
+        }
+
+        Ext.apply(me, config);
+        me.bindings = [];
+
+        if (!me.target.isComponent) {
+            me.target = Ext.get(me.target);
+        }
+
+        if (me.binding) {
+            me.addBinding(me.binding);
+        } else if (config.key) {
+            me.addBinding(config);
+        }
+        me.enable();
+    },
+
+    
+    legacyConstructor: function(el, binding, eventName){
+        var me = this;
+
+        Ext.apply(me, {
+            target: Ext.get(el),
+            eventName: eventName || me.eventName,
+            bindings: []
+        });
+        if (binding) {
+            me.addBinding(binding);
+        }
+        me.enable();
+    },
+
+    
+    addBinding : function(binding){
+        var keyCode = binding.key,
+            processed = false,
+            key,
+            keys,
+            keyString,
+            i,
+            len;
+
+        if (Ext.isArray(binding)) {
+            for (i = 0, len = binding.length; i < len; i++) {
+                this.addBinding(binding[i]);
+            }
+            return;
+        }
+
+        if (Ext.isString(keyCode)) {
+            keys = [];
+            keyString = keyCode.toUpperCase();
+
+            for (i = 0, len = keyString.length; i < len; ++i){
+                keys.push(keyString.charCodeAt(i));
+            }
+            keyCode = keys;
+            processed = true;
+        }
+
+        if (!Ext.isArray(keyCode)) {
+            keyCode = [keyCode];
+        }
+
+        if (!processed) {
+            for (i = 0, len = keyCode.length; i < len; ++i) {
+                key = keyCode[i];
+                if (Ext.isString(key)) {
+                    keyCode[i] = key.toUpperCase().charCodeAt(0);
+                }
+            }
+        }
+
+        this.bindings.push(Ext.apply({
+            keyCode: keyCode
+        }, binding));
+    },
+
+    
+    handleTargetEvent: (function() {
+        var tagRe = /input|textarea/i;
+
+        return function(event) {
+            var me = this,
+                bindings, i, len,
+                target, contentEditable;
+
+            if (this.enabled) { 
+                bindings = this.bindings;
+                i = 0;
+                len = bindings.length;
+
+                
+                event = me.processEvent.apply(me||me.processEventScope, arguments);
+
+                
+                if (me.ignoreInputFields) {
+                    target = event.target;
+                    contentEditable = target.contentEditable;
+                    
+                    
+                    
+                    if (tagRe.test(target.tagName) || (contentEditable === '' || contentEditable === 'true')) {
+                        return;
+                    }
+                }
+
+                
+                
+                if (!event.getKey) {
+                    return event;
+                }
+                for(; i < len; ++i){
+                    this.processBinding(bindings[i], event);
+                }
+            }
+        }
+    }()),
+
+    
+    processEvent: function(event){
+        return event;
+    },
+
+    
+    processBinding: function(binding, event){
+        if (this.checkModifiers(binding, event)) {
+            var key = event.getKey(),
+                handler = binding.fn || binding.handler,
+                scope = binding.scope || this,
+                keyCode = binding.keyCode,
+                defaultEventAction = binding.defaultEventAction,
+                i,
+                len,
+                keydownEvent = new Ext.EventObjectImpl(event);
+
+
+            for (i = 0, len = keyCode.length; i < len; ++i) {
+                if (key === keyCode[i]) {
+                    if (handler.call(scope, key, event) !== true && defaultEventAction) {
+                        keydownEvent[defaultEventAction]();
+                    }
+                    break;
+                }
+            }
+        }
+    },
+
+    
+    checkModifiers: function(binding, e) {
+        var keys = ['shift', 'ctrl', 'alt'],
+            i = 0,
+            len = keys.length,
+            val, key;
+
+        for (; i < len; ++i){
+            key = keys[i];
+            val = binding[key];
+            if (!(val === undefined || (val === e[key + 'Key']))) {
+                return false;
+            }
+        }
+        return true;
+    },
+
+    
+    on: function(key, fn, scope) {
+        var keyCode, shift, ctrl, alt;
+        if (Ext.isObject(key) && !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
+        });
+    },
+
+    
+    isEnabled : function() {
+        return this.enabled;
+    },
+
+    
+    enable: function() {
+        var me = this;
+        
+        if (!me.enabled) {
+            me.target.on(me.eventName, me.handleTargetEvent, me);
+            me.enabled = true;
+        }
+    },
+
+    
+    disable: function() {
+        var me = this;
+        
+        if (me.enabled) {
+            me.target.removeListener(me.eventName, me.handleTargetEvent, me);
+            me.enabled = false;
+        }
+    },
+
+    
+    setDisabled : function(disabled) {
+        if (disabled) {
+            this.disable();
+        } else {
+            this.enable();
+        }
+    },
+
+    
+    destroy: function(removeTarget) {
+        var me = this,
+            target = me.target;
+
+        me.bindings = [];
+        me.disable();
+        if (removeTarget === true) {
+            if (target.isComponent) {
+                target.destroy();
+            } else {
+                target.remove();
+            }
+        }
+        delete me.target;
+    }
+});
+
+
+Ext.define('Ext.util.KeyNav', {
+    alternateClassName: 'Ext.KeyNav',
+    
+    requires: ['Ext.util.KeyMap'],
+    
+    statics: {
+        keyOptions: {
+            left: 37,
+            right: 39,
+            up: 38,
+            down: 40,
+            space: 32,
+            pageUp: 33,
+            pageDown: 34,
+            del: 46,
+            backspace: 8,
+            home: 36,
+            end: 35,
+            enter: 13,
+            esc: 27,
+            tab: 9
+        }
+    },
+
+    constructor: function(config) {
+        var me = this;
+        if (arguments.length === 2) {
+            me.legacyConstructor.apply(me, arguments);
+            return;
+        }
+        me.setConfig(config);
+    },
+
+    
+    legacyConstructor: function(el, config) {
+        this.setConfig(Ext.apply({
+            target: el
+        }, config));
+    },
+
+    
+    setConfig: function(config) {
+        var me = this,
+            keymapCfg = {
+                target: config.target,
+                ignoreInputFields: config.ignoreInputFields,
+                eventName: me.getKeyEvent('forceKeyDown' in config ? config.forceKeyDown : me.forceKeyDown, config.eventName)
+            },
+            map, keyCodes, defaultScope, keyName, binding;
+
+        if (me.map) {
+            me.map.destroy();
+        }
+
+        if (config.processEvent) {
+            keymapCfg.processEvent = config.processEvent;
+            keymapCfg.processEventScope = config.processEventScope||me;
+        }
+        map = me.map = new Ext.util.KeyMap(keymapCfg);
+        keyCodes = Ext.util.KeyNav.keyOptions;
+        defaultScope = config.scope || me;
+        
+        for (keyName in keyCodes) {
+            if (keyCodes.hasOwnProperty(keyName)) {
+
+                
+                
+                if (binding = config[keyName]) {
+                    if (typeof binding === 'function') {
+                        binding = {
+                            handler: binding,
+                            defaultAction: (config.defaultEventAction !== undefined) ? config.defaultEventAction : me.defaultEventAction
+                        };
+                    }
+                    map.addBinding({
+                        key: keyCodes[keyName],
+                        handler: Ext.Function.bind(me.handleEvent, binding.scope||defaultScope, binding.handler||binding.fn, true),
+                        defaultEventAction: (binding.defaultEventAction !== undefined) ? binding.defaultAction : me.defaultEventAction
+                    });
+                }
+            }
+        }
+        
+        map.disable();
+        if (!config.disabled) {
+            map.enable();
+        }
+    },
+    
+    
+    handleEvent: function(keyCode, event, handler){
+        return handler.call(this, event);
+    },
+    
+    
+    disabled: false,
+    
+    
+    defaultEventAction: "stopEvent",
+    
+    
+    forceKeyDown: false,
+
+    
+
+    
+    eventName: 'keypress',
+
+    
+
+    
+
+    
+
+    
+    destroy: function(removeEl) {
+        this.map.destroy(removeEl);
+        delete this.map;
+    },
+
+    
+    enable: function() {
+        this.map.enable();
+        this.disabled = false;
+    },
+
+    
+    disable: function() {
+        this.map.disable();
+        this.disabled = true;
+    },
+    
+    
+    setDisabled : function(disabled) {
+        this.map.setDisabled(disabled);
+        this.disabled = disabled;
+    },
+    
+    
+    getKeyEvent: function(forceKeyDown, configuredEventName) {
+        if (forceKeyDown || (Ext.EventManager.useKeyDown && !configuredEventName)) {
+            return 'keydown';
+        } else {
+            return configuredEventName||this.eventName;
+        }
+    }
+});
+
+
+Ext.define('Ext.FocusManager', {
+    singleton: true,
+    alternateClassName: ['Ext.FocusMgr' ],
+
+    mixins: {
+        observable: 'Ext.util.Observable'
+    },
+
+    requires: [
+        'Ext.AbstractComponent',
+        'Ext.Component',
+        'Ext.ComponentManager',
+        'Ext.ComponentQuery',
+        'Ext.util.HashMap',
+        'Ext.util.KeyNav'
+    ],
+
+    
+    enabled: false,
+
+    
+
+    focusElementCls: Ext.baseCSSPrefix + 'focus-element',
+
+    focusFrameCls: Ext.baseCSSPrefix + 'focus-frame',
+
+    
+    whitelist: [
+        'textfield'
+    ],
+
+    constructor: function(config) {
+        var me = this,
+            CQ = Ext.ComponentQuery;
+
+        me.mixins.observable.constructor.call(me, config);
+
+        me.addEvents(
+            
+            'beforecomponentfocus',
+
+            
+            'componentfocus',
+
+            
+            'disable',
+
+            
+            'enable'
+        );
+
+        me.focusTask = new Ext.util.DelayedTask(me.handleComponentFocus, me);
+
+        
+        Ext.override(Ext.AbstractComponent, {
+            onFocus: function() {
+                this.callParent(arguments);
+                if (me.enabled && this.hasFocus) {
+                    Array.prototype.unshift.call(arguments, this);
+                    me.onComponentFocus.apply(me, arguments);
+                }
+            },
+            onBlur: function() {
+                this.callParent(arguments);
+                if (me.enabled && !this.hasFocus) {
+                    Array.prototype.unshift.call(arguments, this);
+                    me.onComponentBlur.apply(me, arguments);
+                }
+            },
+            onDestroy: function() {
+                this.callParent(arguments);
+                if (me.enabled) {
+                    Array.prototype.unshift.call(arguments, this);
+                    me.onComponentDestroy.apply(me, arguments);
+                }
+            }
+        });
+        Ext.override(Ext.Component, {
+            afterHide: function() {
+                this.callParent(arguments);
+                if (me.enabled) {
+                    Array.prototype.unshift.call(arguments, this);
+                    me.onComponentHide.apply(me, arguments);
+                }
+            }
+        });
+        
+        
+        me.keyNav = new Ext.util.KeyNav(Ext.getDoc(), {
+            disabled: true,
+            scope: me,
+
+            backspace: me.focusLast,
+            enter: me.navigateIn,
+            esc: me.navigateOut,
+            tab: me.navigateSiblings,
+            space: me.navigateIn,
+            del: me.focusLast,
+            left: me.navigateSiblings,
+            right: me.navigateSiblings,
+            down: me.navigateSiblings,
+            up: me.navigateSiblings
+        });
+
+        me.focusData = {};
+        me.subscribers = new Ext.util.HashMap();
+        me.focusChain = {};
+
+        
+        Ext.apply(CQ.pseudos, {
+            focusable: function(cmps) {
+                var len = cmps.length,
+                    results = [],
+                    i = 0,
+                    c;
+
+                for (; i < len; i++) {
+                    c = cmps[i];
+                    if (c.isFocusable()) {
+                        results.push(c);
+                    }
+                }
+
+                return results;
+            },
+
+            
+            nextFocus: function(cmps, idx, step) {
+                step = step || 1;
+                idx = parseInt(idx, 10);
+
+                var len = cmps.length,
+                    i = idx, c;
+
+                for (;;) {
+                    
+                    if ((i += step) >= len) {
+                        i = 0;
+                    } else if (i < 0) {
+                        i = len - 1;
+                    }
+
+                    
+                    if (i === idx) {
+                        return [];
+                    }
+
+                    
+                    if ((c = cmps[i]).isFocusable()) {
+                        return [c];
+                    }
+                }
+
+                return [];
+            },
+
+            prevFocus: function(cmps, idx) {
+                return this.nextFocus(cmps, idx, -1);
+            },
+
+            root: function(cmps) {
+                var len = cmps.length,
+                    results = [],
+                    i = 0,
+                    c;
+
+                for (; i < len; i++) {
+                    c = cmps[i];
+                    if (!c.ownerCt) {
+                        results.push(c);
+                    }
+                }
+
+                return results;
+            }
+        });
+    },
+
+    
+    addXTypeToWhitelist: function(xtype) {
+        var me = this;
+
+        if (Ext.isArray(xtype)) {
+            Ext.Array.forEach(xtype, me.addXTypeToWhitelist, me);
+            return;
+        }
+
+        if (!Ext.Array.contains(me.whitelist, xtype)) {
+            me.whitelist.push(xtype);
+        }
+    },
+
+    clearComponent: function(cmp) {
+        clearTimeout(this.cmpFocusDelay);
+        if (!cmp.isDestroyed) {
+            cmp.blur();
+        }
+    },
+
+    
+    disable: function() {
+        var me = this;
+
+        if (!me.enabled) {
+            return;
+        }
+
+        delete me.options;
+        me.enabled = false;
+
+        me.removeDOM();
+
+        
+        me.keyNav.disable();
+
+        me.fireEvent('disable', me);
+    },
+
+    
+    enable: function(options) {
+        var me = this;
+
+        if (options === true) {
+            options = { focusFrame: true };
+        }
+        me.options = options = options || {};
+
+        if (me.enabled) {
+            return;
+        }
+
+        
+        me.enabled = true;
+        me.initDOM(options);
+
+        
+        me.keyNav.enable();
+
+        
+        me.focusEl.focus();
+        delete me.focusedCmp;
+
+        me.fireEvent('enable', me);
+    },
+
+    focusLast: function(e) {
+        var me = this;
+
+        if (me.isWhitelisted(me.focusedCmp)) {
+            return true;
+        }
+
+        
+        if (me.previousFocusedCmp) {
+            me.previousFocusedCmp.focus();
+        }
+    },
+
+    getRootComponents: function() {
+        var me = this,
+            CQ = Ext.ComponentQuery,
+            inline = CQ.query(':focusable:root:not([floating])'),
+            floating = CQ.query(':focusable:root[floating]');
+
+        
+        
+        floating.sort(function(a, b) {
+            return a.el.getZIndex() > b.el.getZIndex();
+        });
+
+        return floating.concat(inline);
+    },
+
+    initDOM: function(options) {
+        var me = this,
+            cls = me.focusFrameCls,
+            needListeners = Ext.ComponentQuery.query('{getFocusEl()}:not([focusListenerAdded])'),
+            i = 0, len = needListeners.length;
+
+        if (!Ext.isReady) {
+            return Ext.onReady(me.initDOM, me);
+        }
+
+        
+        
+        
+        for (; i < len; i++) {
+            needListeners[i].addFocusListener();
+        }
+
+        
+        if (!me.focusEl) {
+            me.focusEl = Ext.getBody();
+            me.focusEl.dom.tabIndex = -1;
+        }
+
+        
+        if (!me.focusFrame && options.focusFrame) {
+            me.focusFrame = Ext.getBody().createChild({
+                cls: cls,
+                children: [
+                    { cls: cls + '-top' },
+                    { cls: cls + '-bottom' },
+                    { cls: cls + '-left' },
+                    { cls: cls + '-right' }
+                ],
+                style: 'top: -100px; left: -100px;'
+            });
+            me.focusFrame.setVisibilityMode(Ext.Element.DISPLAY);
+            me.focusFrame.hide().setLeftTop(0, 0);
+        }
+    },
+
+    isWhitelisted: function(cmp) {
+        return cmp && Ext.Array.some(this.whitelist, function(x) {
+            return cmp.isXType(x);
+        });
+    },
+
+    navigateIn: function(e) {
+        var me = this,
+            focusedCmp = me.focusedCmp,
+            defaultRoot,
+            firstChild;
+
+        if (me.isWhitelisted(focusedCmp)) {
+            return true;
+        }
+
+        if (!focusedCmp) {
+            
+            defaultRoot = me.getRootComponents()[0];
+            if (defaultRoot) {
+                
+                
+                if (defaultRoot.getFocusEl() === me.focusEl) {
+                    me.focusEl.blur();
+                }
+                defaultRoot.focus();
+            }
+        } else {
+            
+            
+            firstChild = focusedCmp.hasFocus ? Ext.ComponentQuery.query('>:focusable', focusedCmp)[0] : focusedCmp;
+            if (firstChild) {
+                firstChild.focus();
+            } else {
+                
+                if (Ext.isFunction(focusedCmp.onClick)) {
+                    e.button = 0;
+                    focusedCmp.onClick(e);
+                    if (focusedCmp.isVisible(true)) {
+                        focusedCmp.focus();
+                    } else {
+                        me.navigateOut();
+                    }
+                }
+            }
+        }
+    },
+
+    navigateOut: function(e) {
+        var me = this,
+            parent;
+
+        if (!me.focusedCmp || !(parent = me.focusedCmp.up(':focusable'))) {
+            me.focusEl.focus();
+        } else {
+            parent.focus();
+        }
+
+        
+        
+        
+        return true;
+    },
+
+    navigateSiblings: function(e, source, parent) {
+        var me = this,
+            src = source || me,
+            key = e.getKey(),
+            EO = Ext.EventObject,
+            goBack = e.shiftKey || key == EO.LEFT || key == EO.UP,
+            checkWhitelist = key == EO.LEFT || key == EO.RIGHT || key == EO.UP || key == EO.DOWN,
+            nextSelector = goBack ? 'prev' : 'next',
+            idx, next, focusedCmp, siblings;
+
+        focusedCmp = (src.focusedCmp && src.focusedCmp.comp) || src.focusedCmp;
+        if (!focusedCmp && !parent) {
+            return true;
+        }
+
+        if (checkWhitelist && me.isWhitelisted(focusedCmp)) {
+            return true;
+        }
+
+        
+        if (!focusedCmp || focusedCmp.is(':root')) {
+            siblings = me.getRootComponents();
+        } else {
+            
+            parent = parent || focusedCmp.up();
+            if (parent) {
+                siblings = parent.getRefItems();
+            }
+        }
+
+
+        
+        if (siblings) {
+            idx = focusedCmp ? Ext.Array.indexOf(siblings, focusedCmp) : -1;
+            next = Ext.ComponentQuery.query(':' + nextSelector + 'Focus(' + idx + ')', siblings)[0];
+            if (next && focusedCmp !== next) {
+                next.focus();
+                return next;
+            }
+        }
+    },
+
+    onComponentBlur: function(cmp, e) {
+        var me = this;
+
+        if (me.focusedCmp === cmp) {
+            me.previousFocusedCmp = cmp;
+            delete me.focusedCmp;
+        }
+
+        if (me.focusFrame) {
+            me.focusFrame.hide();
+        }
+    },
+
+    onComponentFocus: function(cmp, e) {
+        var me = this,
+            chain = me.focusChain,
+            parent;
+
+        if (!cmp.isFocusable()) {
+            me.clearComponent(cmp);
+
+            
+            
+            
+            
+            if (chain[cmp.id]) {
+                return;
+            }
+
+            
+            parent = cmp.up();
+            if (parent) {
+                
+                
+                
+                chain[cmp.id] = true;
+                parent.focus();
+            }
+
+            return;
+        }
+        
+        me.focusChain = {};
+
+        
+        
+        
+        me.focusTask.delay(10, null, null, [cmp, cmp.getFocusEl()]);
+    },
+
+    handleComponentFocus: function(cmp, focusEl) {
+        var me = this,
+            cls,
+            ff,
+            fw,
+            box,
+            bt,
+            bl,
+            bw,
+            bh,
+            ft,
+            fb,
+            fl,
+            fr;
+
+        if (me.fireEvent('beforecomponentfocus', me, cmp, me.previousFocusedCmp) === false) {
+            me.clearComponent(cmp);
+            return;
+        }
+
+        me.focusedCmp = cmp;
+
+        
+        if (me.shouldShowFocusFrame(cmp)) {
+            cls = '.' + me.focusFrameCls + '-';
+            ff = me.focusFrame;
+            box = focusEl.getPageBox();
+
+            
+            
+            
+            bt = box.top;
+            bl = box.left;
+            bw = box.width;
+            bh = box.height;
+            ft = ff.child(cls + 'top');
+            fb = ff.child(cls + 'bottom');
+            fl = ff.child(cls + 'left');
+            fr = ff.child(cls + 'right');
+
+            ft.setWidth(bw).setLeftTop(bl, bt);
+            fb.setWidth(bw).setLeftTop(bl, bt + bh - 2);
+            fl.setHeight(bh - 2).setLeftTop(bl, bt + 2);
+            fr.setHeight(bh - 2).setLeftTop(bl + bw - 2, bt + 2);
+
+            ff.show();
+        }
+
+        me.fireEvent('componentfocus', me, cmp, me.previousFocusedCmp);
+    },
+
+    onComponentHide: function(cmp) {
+        var me = this,
+            cmpHadFocus = false,
+            focusedCmp = me.focusedCmp,
+            parent;
+
+        if (focusedCmp) {
+            
+            
+            cmpHadFocus = cmp.hasFocus || (cmp.isContainer && cmp.isAncestor(me.focusedCmp));
+        }
+
+        me.clearComponent(cmp);
+
+        
+        if (cmpHadFocus && (parent = cmp.up(':focusable'))) {
+            parent.focus();
+        } else {
+            me.focusEl.focus();
+        }
+    },
+
+    onComponentDestroy: function() {
+
+    },
+
+    removeDOM: function() {
+        var me = this;
+
+        
+        
+        if (me.enabled || me.subscribers.length) {
+            return;
+        }
+
+        Ext.destroy(
+            me.focusFrame
+        );
+        delete me.focusEl;
+        delete me.focusFrame;
+    },
+
+    
+    removeXTypeFromWhitelist: function(xtype) {
+        var me = this;
+
+        if (Ext.isArray(xtype)) {
+            Ext.Array.forEach(xtype, me.removeXTypeFromWhitelist, me);
+            return;
+        }
+
+        Ext.Array.remove(me.whitelist, xtype);
+    },
+
+    setupSubscriberKeys: function(container, keys) {
+        var me = this,
+            el = container.getFocusEl(),
+            scope = keys.scope,
+            handlers = {
+                backspace: me.focusLast,
+                enter: me.navigateIn,
+                esc: me.navigateOut,
+                scope: me
+            },
+
+            navSiblings = function(e) {
+                if (me.focusedCmp === container) {
+                    
+                    
+                    
+                    return me.navigateSiblings(e, me, container);
+                } else {
+                    return me.navigateSiblings(e);
+                }
+            };
+
+        Ext.iterate(keys, function(key, cb) {
+            handlers[key] = function(e) {
+                var ret = navSiblings(e);
+
+                if (Ext.isFunction(cb) && cb.call(scope || container, e, ret) === true) {
+                    return true;
+                }
+
+                return ret;
+            };
+        }, me);
+
+        return new Ext.util.KeyNav(el, handlers);
+    },
+
+    shouldShowFocusFrame: function(cmp) {
+        var me = this,
+            opts = me.options || {},
+            cmpFocusEl = cmp.getFocusEl(),
+            cmpFocusElTag = Ext.getDom(cmpFocusEl).tagName;
+
+        
+        
+        
+        if (!me.focusFrame || !cmp) {
+            return false;
+        }
+
+        
+        if (opts.focusFrame) {
+            return true;
+        }
+
+        if (me.focusData[cmp.id].focusFrame) {
+            return true;
+        }
+
+        return false;
+    }
+});
+
+
+Ext.define('Ext.Img', {
+    extend: 'Ext.Component',
+    alias: ['widget.image', 'widget.imagecomponent'],
+
+    autoEl: 'img',
+
+    
+    src: '',
+
+    
+    alt: '',
+
+    
+    imgCls: '',
+
+    getElConfig: function() {
+        var me = this,
+            config = me.callParent(),
+            img;
+
+        
+        
+        if (me.autoEl == 'img') {
+            img = config;
+        } else {
+            config.cn = [img = {
+                tag: 'img',
+                id: me.id + '-img'
+            }];
+        }
+
+        if (me.imgCls) {
+            img.cls = (img.cls ? img.cls + ' ' : '') + me.imgCls;
+        }
+
+        img.src = me.src || Ext.BLANK_IMAGE_URL;
+        if (me.alt) {
+            img.alt = me.alt;
+        }
+
+        return config;
+    },
+
+    onRender: function () {
+        var me = this,
+            el;
+
+        me.callParent(arguments);
+
+        el = me.el;
+        me.imgEl = (me.autoEl == 'img') ? el : el.getById(me.id + '-img');
+    },
+
+    onDestroy: function () {
+        Ext.destroy(this.imgEl);
+        this.imgEl = null;
+        this.callParent();
+    },
+
+    
+    setSrc: function(src) {
+        var me = this,
+            imgEl = me.imgEl;
+
+        me.src = src;
+
+        if (imgEl) {
+            imgEl.dom.src = src || Ext.BLANK_IMAGE_URL;
+        }
+    }
+});
+
+
+Ext.define('Ext.Layer', {
+    extend: 'Ext.Element',
+    uses: ['Ext.Shadow'],
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+    statics: {
+        shims: []
+    },
+    
+    isLayer: true,
+
+    
+    constructor: function(config, existingEl) {
+        config = config || {};
+        var me = this,
+            dh = Ext.DomHelper,
+            cp = config.parentEl,
+            pel = cp ? Ext.getDom(cp) : document.body,
+        hm = config.hideMode;
+
+        if (existingEl) {
+            me.dom = Ext.getDom(existingEl);
+        }
+        if (!me.dom) {
+            me.dom = dh.append(pel, config.dh || {
+                tag: 'div',
+                cls: Ext.baseCSSPrefix + 'layer' 
+            });
+        } else {
+            me.addCls(Ext.baseCSSPrefix + 'layer');
+            if (!me.dom.parentNode) {
+                pel.appendChild(me.dom);
+            }
+        }
+
+        if (config.id) {
+            me.id = me.dom.id = config.id;
+        } else {
+            me.id = Ext.id(me.dom);
+        }
+
+        Ext.Element.addToCache(me);
+
+        if (config.cls) {
+            me.addCls(config.cls);
+        }
+        me.constrain = config.constrain !== false;
+
+        
+        
+        
+        if (hm) {
+            me.setVisibilityMode(Ext.Element[hm.toUpperCase()]);
+            if (me.visibilityMode == Ext.Element.ASCLASS) {
+                me.visibilityCls = config.visibilityCls;
+            }
+        } else if (config.useDisplay) {
+            me.setVisibilityMode(Ext.Element.DISPLAY);
+        } else {
+            me.setVisibilityMode(Ext.Element.VISIBILITY);
+        }
+
+        if (config.shadow) {
+            me.shadowOffset = config.shadowOffset || 4;
+            me.shadow = new Ext.Shadow({
+                offset: me.shadowOffset,
+                mode: config.shadow
+            });
+            me.disableShadow();
+        } else {
+            me.shadowOffset = 0;
+        }
+        me.useShim = config.shim !== false && Ext.useShims;
+        if (config.hidden === true) {
+            me.hide();
+        } else {
+            me.show();
+        }
+    },
+
+    getZIndex: function() {
+        return parseInt((this.getShim() || this).getStyle('z-index'), 10);
+    },
+
+    getShim: function() {
+        var me = this,
+            shim, pn;
+
+        if (!me.useShim) {
+            return null;
+        }
+        if (!me.shim) {
+            shim = me.self.shims.shift();
+            if (!shim) {
+                shim = me.createShim();
+                shim.enableDisplayMode('block');
+                shim.hide();
+            }
+            pn = me.dom.parentNode;
+            if (shim.dom.parentNode != pn) {
+                pn.insertBefore(shim.dom, me.dom);
+            }
+            me.shim = shim;
+        }
+        return me.shim;
+    },
+
+    hideShim: function() {
+        var me = this;
+        
+        if (me.shim) {
+            me.shim.setDisplayed(false);
+            me.self.shims.push(me.shim);
+            delete me.shim;
+        }
+    },
+
+    disableShadow: function() {
+        var me = this;
+        
+        if (me.shadow && !me.shadowDisabled) {
+            me.shadowDisabled = true;
+            me.shadow.hide();
+            me.lastShadowOffset = me.shadowOffset;
+            me.shadowOffset = 0;
+        }
+    },
+
+    enableShadow: function(show) {
+        var me = this;
+        
+        if (me.shadow && me.shadowDisabled) {
+            me.shadowDisabled = false;
+            me.shadowOffset = me.lastShadowOffset;
+            delete me.lastShadowOffset;
+            if (show) {
+                me.sync(true);
+            }
+        }
+    },
+
+    
+    sync: function(doShow) {
+        var me = this,
+            shadow = me.shadow,
+            shadowPos, shimStyle, shadowSize,
+            shim, l, t, w, h, shimIndex;
+
+        if (!me.updating && me.isVisible() && (shadow || me.useShim)) {
+            shim = me.getShim();
+            l = me.getLocalX();
+            t = me.getLocalY();
+            w = me.dom.offsetWidth;
+            h = me.dom.offsetHeight;
+
+            if (shadow && !me.shadowDisabled) {
+                if (doShow && !shadow.isVisible()) {
+                    shadow.show(me);
+                } else {
+                    shadow.realign(l, t, w, h);
+                }
+                if (shim) {
+                    
+                    shimIndex = shim.getStyle('z-index');
+                    if (shimIndex > me.zindex) {
+                        me.shim.setStyle('z-index', me.zindex - 2);
+                    }
+                    shim.show();
+                    
+                    if (shadow.isVisible()) {
+                        shadowPos = shadow.el.getXY();
+                        shimStyle = shim.dom.style;
+                        shadowSize = shadow.el.getSize();
+                        if (Ext.supports.CSS3BoxShadow) {
+                            shadowSize.height += 6;
+                            shadowSize.width += 4;
+                            shadowPos[0] -= 2;
+                            shadowPos[1] -= 4;
+                        }
+                        shimStyle.left = (shadowPos[0]) + 'px';
+                        shimStyle.top = (shadowPos[1]) + 'px';
+                        shimStyle.width = (shadowSize.width) + 'px';
+                        shimStyle.height = (shadowSize.height) + 'px';
+                    } else {
+                        shim.setSize(w, h);
+                        shim.setLeftTop(l, t);
+                    }
+                }
+            } else if (shim) {
+                
+                shimIndex = shim.getStyle('z-index');
+                if (shimIndex > me.zindex) {
+                    me.shim.setStyle('z-index', me.zindex - 2);
+                }
+                shim.show();
+                shim.setSize(w, h);
+                shim.setLeftTop(l, t);
+            }
+        }
+        return me;
+    },
+
+    remove: function() {
+        this.hideUnders();
+        this.callParent();
+    },
+
+    
+    beginUpdate: function() {
+        this.updating = true;
+    },
+
+    
+    endUpdate: function() {
+        this.updating = false;
+        this.sync(true);
+    },
+
+    
+    hideUnders: function() {
+        if (this.shadow) {
+            this.shadow.hide();
+        }
+        this.hideShim();
+    },
+
+    
+    constrainXY: function() {
+        if (this.constrain) {
+            var vw = Ext.Element.getViewWidth(),
+                vh = Ext.Element.getViewHeight(),
+                s = Ext.getDoc().getScroll(),
+                xy = this.getXY(),
+                x = xy[0],
+                y = xy[1],
+                so = this.shadowOffset,
+                w = this.dom.offsetWidth + so,
+                h = this.dom.offsetHeight + so,
+                moved = false; 
+            
+            if ((x + w) > vw + s.left) {
+                x = vw - w - so;
+                moved = true;
+            }
+            if ((y + h) > vh + s.top) {
+                y = vh - h - so;
+                moved = true;
+            }
+            
+            if (x < s.left) {
+                x = s.left;
+                moved = true;
+            }
+            if (y < s.top) {
+                y = s.top;
+                moved = true;
+            }
+            if (moved) {
+                Ext.Layer.superclass.setXY.call(this, [x, y]);
+                this.sync();
+            }
+        }
+        return this;
+    },
+
+    getConstrainOffset: function() {
+        return this.shadowOffset;
+    },
+
+    
+    setVisible: function(visible, animate, duration, callback, easing) {
+        var me = this,
+            cb;
+
+        
+        cb = function() {
+            if (visible) {
+                me.sync(true);
+            }
+            if (callback) {
+                callback();
+            }
+        };
+
+        
+        if (!visible) {
+            me.hideUnders(true);
+        }
+        me.callParent([visible, animate, duration, callback, easing]);
+        if (!animate) {
+            cb();
+        }
+        return me;
+    },
+
+    
+    beforeFx: function() {
+        this.beforeAction();
+        return this.callParent(arguments);
+    },
+
+    
+    afterFx: function() {
+        this.callParent(arguments);
+        this.sync(this.isVisible());
+    },
+
+    
+    beforeAction: function() {
+        if (!this.updating && this.shadow) {
+            this.shadow.hide();
+        }
+    },
+
+    
+    setLeft: function(left) {
+        this.callParent(arguments);
+        return this.sync();
+    },
+
+    setTop: function(top) {
+        this.callParent(arguments);
+        return this.sync();
+    },
+
+    setLeftTop: function(left, top) {
+        this.callParent(arguments);
+        return this.sync();
+    },
+
+    setXY: function(xy, animate, duration, callback, easing) {
+        var me = this;
+        
+        
+        callback = me.createCB(callback);
+
+        me.fixDisplay();
+        me.beforeAction();
+        me.callParent([xy, animate, duration, callback, easing]);
+        if (!animate) {
+            callback();
+        }
+        return me;
+    },
+
+    
+    createCB: function(callback) {
+        var me = this,
+            showShadow = me.shadow && me.shadow.isVisible();
+
+        return function() {
+            me.constrainXY();
+            me.sync(showShadow);
+            if (callback) {
+                callback();
+            }
+        };
+    },
+
+    
+    setX: function(x, animate, duration, callback, easing) {
+        this.setXY([x, this.getY()], animate, duration, callback, easing);
+        return this;
+    },
+
+    
+    setY: function(y, animate, duration, callback, easing) {
+        this.setXY([this.getX(), y], animate, duration, callback, easing);
+        return this;
+    },
+
+    
+    setSize: function(w, h, animate, duration, callback, easing) {
+        var me = this;
+        
+        
+        callback = me.createCB(callback);
+
+        me.beforeAction();
+        me.callParent([w, h, animate, duration, callback, easing]);
+        if (!animate) {
+            callback();
+        }
+        return me;
+    },
+
+    
+    setWidth: function(w, animate, duration, callback, easing) {
+        var me = this;
+        
+        
+        callback = me.createCB(callback);
+
+        me.beforeAction();
+        me.callParent([w, animate, duration, callback, easing]);
+        if (!animate) {
+            callback();
+        }
+        return me;
+    },
+
+    
+    setHeight: function(h, animate, duration, callback, easing) {
+        var me = this;
+        
+        
+        callback = me.createCB(callback);
+
+        me.beforeAction();
+        me.callParent([h, animate, duration, callback, easing]);
+        if (!animate) {
+            callback();
+        }
+        return me;
+    },
+
+    
+    setBounds: function(x, y, width, height, animate, duration, callback, easing) {
+        var me = this;
+        
+        
+        callback = me.createCB(callback);
+
+        me.beforeAction();
+        if (!animate) {
+            Ext.Layer.superclass.setXY.call(me, [x, y]);
+            Ext.Layer.superclass.setSize.call(me, width, height);
+            callback();
+        } else {
+            me.callParent([x, y, width, height, animate, duration, callback, easing]);
+        }
+        return me;
+    },
+
+    
+    setZIndex: function(zindex) {
+        var me = this;
+        
+        me.zindex = zindex;
+        if (me.getShim()) {
+            me.shim.setStyle('z-index', zindex++);
+        }
+        if (me.shadow) {
+            me.shadow.setZIndex(zindex++);
+        }
+        return me.setStyle('z-index', zindex);
+    },
+    
+    onOpacitySet: function(opacity){
+        var shadow = this.shadow;
+        if (shadow) {
+            shadow.setOpacity(opacity);
+        }
+    }
+});
+
+
+Ext.define('Ext.util.Bindable', {
+    
+    
+    bindStore: function(store, initial){
+        var me = this,
+            oldStore = me.store;
+        
+        if (!initial && me.store) {
+            
+            me.onUnbindStore(oldStore, initial);
+
+            if (store !== oldStore && oldStore.autoDestroy) {
+                oldStore.destroyStore();
+            } else {
+                me.unbindStoreListeners(oldStore);
+            }
+        }
+        if (store) {
+            store = Ext.data.StoreManager.lookup(store);
+            me.bindStoreListeners(store);
+            me.onBindStore(store, initial);
+        }
+        me.store = store || null;
+        return me;
+    },
+    
+    
+    getStore: function(){
+        return this.store;
+    },
+    
+    
+    unbindStoreListeners: function(store) {
+        
+        var listeners = this.storeListeners;
+        if (listeners) {
+            store.un(listeners);
+        }
+    },
+    
+    
+    bindStoreListeners: function(store) {
+        
+        var me = this,
+            listeners = Ext.apply({}, me.getStoreListeners());
+            
+        if (!listeners.scope) {
+            listeners.scope = me;
+        }
+        me.storeListeners = listeners;
+        store.on(listeners);
+    },
+    
+    
+    getStoreListeners: Ext.emptyFn,
+    
+    
+    onUnbindStore: Ext.emptyFn,
+    
+    
+    onBindStore: Ext.emptyFn    
+});
+
+
+Ext.define('Ext.LoadMask', {
+
+    extend: 'Ext.Component',
+
+    alias: 'widget.loadmask',
+
+    
+
+    mixins: {
+        floating: 'Ext.util.Floating',
+        bindable: 'Ext.util.Bindable'
+    },
+
+    uses: ['Ext.data.StoreManager'],
+
+    
+
+    
+
+    
+    
+    msg : 'Loading...',
+    
+
+    
+    msgCls : Ext.baseCSSPrefix + 'mask-loading',
+
+    
+    maskCls: Ext.baseCSSPrefix + 'mask',
+
+    
+    useMsg: true,
+
+    
+    useTargetEl: false,
+
+    baseCls: Ext.baseCSSPrefix + 'mask-msg',
+
+    childEls: [
+        'msgEl'
+    ],
+
+    renderTpl: '<div id="{id}-msgEl" style="position:relative" class="{[values.$comp.msgCls]}"></div>',
+
+    
+    floating: {
+        shadow: 'frame'
+    },
+
+    
+    focusOnToFront: false,
+
+    
+    
+    bringParentToFront: false,
+
+    
+    constructor : function(comp, config) {
+        var me = this;
+
+        
+        if (!comp.isComponent) {
+            comp = Ext.get(comp);
+            this.isElement = true;
+        }
+
+        me.ownerCt = comp;
+        if (!this.isElement) {
+            me.bindComponent(comp);
+        }
+        me.callParent([config]);
+
+        if (me.store) {
+            me.bindStore(me.store, true);
+        }
+    },
+
+    bindComponent: function(comp){
+        var me = this,
+            listeners = {
+                scope: this,
+                resize: me.sizeMask,
+                added: me.onComponentAdded,
+                removed: me.onComponentRemoved
+            },
+            hierarchyEventSource = Ext.container.Container.hierarchyEventSource;
+            
+        if (comp.floating) {
+            listeners.move = me.sizeMask;
+            me.activeOwner = comp;
+        } else if (comp.ownerCt) {
+            me.onComponentAdded(comp.ownerCt);
+        } else {
+            
+            me.preventBringToFront = true;
+        }
+
+        me.mon(comp, listeners);
+        
+        
+        me.mon(hierarchyEventSource, {
+            show: me.onContainerShow,
+            hide: me.onContainerHide,
+            expand: me.onContainerExpand,
+            collapse: me.onContainerCollapse,
+            scope: me
+        });
+    },
+
+    onComponentAdded: function(owner){
+        var me = this;
+        delete me.activeOwner;
+        me.floatParent = owner;
+        if (!owner.floating) {
+            owner = owner.up('[floating]');
+        }
+        if (owner) {
+            me.activeOwner = owner;
+            me.mon(owner, 'move', me.sizeMask, me);
+        }
+        owner = me.floatParent.ownerCt;
+        if (me.rendered && me.isVisible() && owner) {
+            me.floatOwner = owner;
+            me.mon(owner, 'afterlayout', me.sizeMask, me, {single: true});
+        }
+    },
+
+    onComponentRemoved: function(owner){
+        var me = this,
+            activeOwner = me.activeOwner,
+            floatOwner = me.floatOwner;
+
+        if (activeOwner) {
+            me.mun(activeOwner, 'move', me.sizeMask, me);
+        }
+        if (floatOwner) {
+            me.mun(floatOwner, 'afterlayout', me.sizeMask, me);
+        }
+        delete me.activeOwner;
+        delete me.floatOwner;
+    },
+
+    afterRender: function() {
+        this.callParent(arguments);
+        this.container = this.floatParent.getContentTarget();
+    },
+
+    onContainerShow: function(container){
+        if (this.isActiveContainer(container)) {
+            this.onComponentShow();
+        }
+    },
+
+    onContainerHide: function(container){
+        if (this.isActiveContainer(container)) {
+            this.onComponentHide();
+        }
+    },
+
+    onContainerExpand: function(container){
+        if (this.isActiveContainer(container)) {
+            this.onComponentShow();
+        }
+    },
+
+    onContainerCollapse: function(container){
+        if (this.isActiveContainer(container)) {
+            this.onComponentHide();
+        }
+    },
+
+    isActiveContainer: function(container){
+        return this.isDescendantOf(container);
+    },
+
+    onComponentHide: function(){
+        var me = this;
+
+        if (me.rendered && me.isVisible()) {
+            me.hide();
+            me.showNext = true;
+        }
+    },
+
+    onComponentShow: function(){
+        if (this.showNext) {
+            this.show();
+        }
+        delete this.showNext;
+    },
+
+    
+    sizeMask: function() {
+        var me = this,
+            target;
+
+        if (me.rendered && me.isVisible()) {
+            me.center();
+
+            target = me.getMaskTarget();
+            me.getMaskEl().show().setSize(target.getSize()).alignTo(target, 'tl-tl');
+
+        }
+    },
+
+    
+    bindStore : function(store, initial) {
+        var me = this;
+        me.mixins.bindable.bindStore.apply(me, arguments);
+        store = me.store;
+        if (store && store.isLoading()) {
+            me.onBeforeLoad();
+        }
+    },
+
+    getStoreListeners: function(){
+        return {
+            beforeload: this.onBeforeLoad,
+            load: this.onLoad,
+            exception: this.onLoad,
+
+            
+            cachemiss: this.onBeforeLoad,
+
+            
+            cachefilled: this.onLoad
+        };
+    },
+
+    onDisable : function() {
+        this.callParent(arguments);
+        if (this.loading) {
+            this.onLoad();
+        }
+    },
+
+    getOwner: function(){
+        return this.ownerCt || this.floatParent;
+    },
+
+    getMaskTarget: function(){
+        var owner = this.getOwner();
+        return this.useTargetEl ? owner.getTargetEl() : owner.getEl();
+    },
+
+    
+    onBeforeLoad : function() {
+        var me = this,
+            owner = me.getOwner(),
+            origin;
+
+        if (!me.disabled) {
+            me.loading = true;
+            
+            
+            if (owner.componentLayoutCounter) {
+                me.maybeShow();
+            } else {
+                
+                origin = owner.afterComponentLayout;
+                owner.afterComponentLayout = function() {
+                    owner.afterComponentLayout = origin;
+                    origin.apply(owner, arguments);
+                    me.maybeShow();
+                };
+            }
+        }
+    },
+
+    maybeShow: function(){
+        var me = this,
+            owner = me.getOwner();
+
+        if (!owner.isVisible(true)) {
+            me.showNext = true;
+        }
+        else if (me.loading && owner.rendered) {
+            me.show();
+        }
+    },
+
+    getMaskEl: function(){
+        var me = this;
+        return me.maskEl || (me.maskEl = me.el.insertSibling({
+            cls: me.maskCls,
+            style: {
+                zIndex: me.el.getStyle('zIndex') - 2
+            }
+        }, 'before'));
+    },
+
+    onShow: function() {
+        var me = this,
+            msgEl = me.msgEl;
+
+        me.callParent(arguments);
+        me.loading = true;
+
+        if (me.useMsg) {
+            msgEl.show().update(me.msg);
+        } else {
+            msgEl.parent().hide();
+        }
+    },
+
+    hide: function(){
+        
+        if (this.isElement) {
+            this.ownerCt.unmask();
+            this.fireEvent('hide', this);
+            return;
+        }
+        delete this.showNext;
+        return this.callParent(arguments);
+    },
+
+    onHide: function(){
+        this.callParent();
+        this.getMaskEl().hide();
+    },
+
+    show: function(){
+        
+        if (this.isElement) {
+            this.ownerCt.mask(this.useMsg ? this.msg : '', this.msgCls);
+            this.fireEvent('show', this);
+            return;
+        }
+        return this.callParent(arguments);
+    },
+
+    afterShow: function() {
+        this.callParent(arguments);
+        this.sizeMask();
+    },
+
+    setZIndex: function(index) {
+        var me = this,
+            owner = me.activeOwner;
+            
+        if (owner) {
+            
+            
+            
+            index = parseInt(owner.el.getStyle('zIndex'), 10) + 1;
+        }
+
+        me.getMaskEl().setStyle('zIndex', index - 1);
+        return me.mixins.floating.setZIndex.apply(me, arguments);
+    },
+
+    
+    onLoad : function() {
+        this.loading = false;
+        this.hide();
+    },
+
+    onDestroy: function(){
+        var me = this;
+
+        if (me.isElement) {
+            me.ownerCt.unmask();
+        }
+
+        Ext.destroy(me.maskEl);
+        me.callParent();
+    }
+});
+
+
+Ext.define('Ext.data.association.Association', {
+    alternateClassName: 'Ext.data.Association',
+    
+
+    
+
+    
+
+    
+    primaryKey: 'id',
+
+    
+    
+    
+
+    defaultReaderType: 'json',
+
+    isAssociation: true,
+
+    initialConfig: null,
+
+    statics: {
+        AUTO_ID: 1000,
+        
+        create: function(association){
+            if (Ext.isString(association)) {
+                association = {
+                    type: association
+                };
+            }
+
+            switch (association.type) {
+                case 'belongsTo':
+                    return new Ext.data.association.BelongsTo(association);
+                case 'hasMany':
+                    return new Ext.data.association.HasMany(association);
+                case 'hasOne':
+                    return new Ext.data.association.HasOne(association);
+                
+
+
+                default:
+            }
+            return association;
+        }
+    },
+
+    
+    constructor: function(config) {
+        Ext.apply(this, config);
+
+        var me = this,
+            types           = Ext.ModelManager.types,
+            ownerName       = config.ownerModel,
+            associatedName  = config.associatedModel,
+            ownerModel      = types[ownerName],
+            associatedModel = types[associatedName];
+
+        me.initialConfig = config;
+
+
+        me.ownerModel = ownerModel;
+        me.associatedModel = associatedModel;
+
+        
+
+        
+
+        Ext.applyIf(me, {
+            ownerName : ownerName,
+            associatedName: associatedName
+        });
+        
+        me.associationId = 'association' + (++me.statics().AUTO_ID);
+    },
+
+    
+    getReader: function(){
+        var me = this,
+            reader = me.reader,
+            model = me.associatedModel;
+
+        if (reader) {
+            if (Ext.isString(reader)) {
+                reader = {
+                    type: reader
+                };
+            }
+            if (reader.isReader) {
+                reader.setModel(model);
+            } else {
+                Ext.applyIf(reader, {
+                    model: model,
+                    type : me.defaultReaderType
+                });
+            }
+            me.reader = Ext.createByAlias('reader.' + reader.type, reader);
+        }
+        return me.reader || null;
+    }
+});
+
+
+Ext.define('Ext.ModelManager', {
+    extend: 'Ext.AbstractManager',
+    alternateClassName: 'Ext.ModelMgr',
+    requires: ['Ext.data.association.Association'],
+    
+    singleton: true,
+
+    typeName: 'mtype',
+
+    
+    associationStack: [],
+
+    
+    registerType: function(name, config) {
+        var proto = config.prototype,
+            model;
+        if (proto && proto.isModel) {
+            
+            model = config;
+        } else {
+            
+            if (!config.extend) {
+                config.extend = 'Ext.data.Model';
+            }
+            model = Ext.define(name, config);
+        }
+        this.types[name] = model;
+        return model;
+    },
+
+    
+    onModelDefined: function(model) {
+        var stack  = this.associationStack,
+            length = stack.length,
+            create = [],
+            association, i, created;
+
+        for (i = 0; i < length; i++) {
+            association = stack[i];
+
+            if (association.associatedModel == model.modelName) {
+                create.push(association);
+            }
+        }
+
+        for (i = 0, length = create.length; i < length; i++) {
+            created = create[i];
+            this.types[created.ownerModel].prototype.associations.add(Ext.data.association.Association.create(created));
+            Ext.Array.remove(stack, created);
+        }
+    },
+
+    
+    registerDeferredAssociation: function(association){
+        this.associationStack.push(association);
+    },
+
+    
+    getModel: function(id) {
+        var model = id;
+        if (typeof model == 'string') {
+            model = this.types[model];
+        }
+        return model;
+    },
+
+    
+    create: function(config, name, id) {
+        var Con = typeof name == 'function' ? name : this.types[name || config.name];
+
+        return new Con(config, id);
+    }
+}, function() {
+
+    
+    Ext.regModel = function() {
+        return this.ModelManager.registerType.apply(this.ModelManager, arguments);
+    };
+});
+
+
+Ext.define('Ext.PluginManager', {
+    extend: 'Ext.AbstractManager',
+    alternateClassName: 'Ext.PluginMgr',
+    singleton: true,
+    typeName: 'ptype',
+
+    
+    create : function(config, defaultType){
+        if (config.init) {
+            return config;
+        } else {
+            return Ext.createByAlias('plugin.' + (config.ptype || defaultType), config);
+        }
+
+        
+        
+        
+        
+        
+        
+        
+    },
+
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+
+    
+    findByType: function(type, defaultsOnly) {
+        var matches = [],
+            types   = this.types,
+            name,
+            item;
+
+        for (name in types) {
+            if (!types.hasOwnProperty(name)) {
+                continue;
+            }
+            item = types[name];
+
+            if (item.type == type && (!defaultsOnly || (defaultsOnly === true && item.isDefault))) {
+                matches.push(item);
+            }
+        }
+
+        return matches;
+    }
+}, function() {
+    
+    Ext.preg = function() {
+        return Ext.PluginManager.registerType.apply(Ext.PluginManager, arguments);
+    };
+});
+
+
+Ext.define('Ext.layout.component.ProgressBar', {
+
+    
+
+    alias: ['layout.progressbar'],
+
+    extend: 'Ext.layout.component.Auto',
+
+    
+
+    type: 'progressbar',
+
+    beginLayout: function (ownerContext) {
+        var me = this,
+            i, textEls;
+
+        me.callParent(arguments);
+
+        if (!ownerContext.textEls) {
+            textEls = me.owner.textEl; 
+
+            if (textEls.isComposite) {
+                ownerContext.textEls = [];
+                textEls = textEls.elements;
+                for (i = textEls.length; i--; ) {
+                    ownerContext.textEls[i] = ownerContext.getEl(Ext.get(textEls[i]));
+                }
+            } else {
+                ownerContext.textEls = [ ownerContext.getEl('textEl') ];
+            }
+        }
+    },
+
+    calculate: function(ownerContext) {
+        var me = this,
+            i, textEls, width;
+
+        me.callParent(arguments);
+
+        if (Ext.isNumber(width = ownerContext.getProp('width'))) {
+            width -= ownerContext.getBorderInfo().width;
+            textEls = ownerContext.textEls;
+
+            for (i = textEls.length; i--; ) {
+                textEls[i].setWidth(width);
+            }
+        } else {
+            me.done = false;
+        }
+    }
+});
+
+//@tag dom,core
+
+
+Ext.define('Ext.dom.CompositeElement', {
+    alternateClassName: 'Ext.CompositeElement',
+
+    extend: 'Ext.dom.CompositeElementLite',
+
+    
+    getElement: function(el) {
+        
+        return el;
+    },
+
+    
+    transformElement: function(el) {
+        return Ext.get(el);
+    }
+
+}, function() {
+    
+
+    Ext.dom.Element.select = function(selector, unique, root) {
+        var elements;
+
+        if (typeof selector == "string") {
+            elements = Ext.dom.Element.selectorFunction(selector, root);
+        }
+        else if (selector.length !== undefined) {
+            elements = selector;
+        }
+        else {
+        }
+        return (unique === true) ? new Ext.CompositeElement(elements) : new Ext.CompositeElementLite(elements);
+    };
+});
+
+
+Ext.select = Ext.Element.select;
+
+
+Ext.define('Ext.ProgressBar', {
+    extend: 'Ext.Component',
+    alias: 'widget.progressbar',
+
+    requires: [
+        'Ext.Template',
+        'Ext.CompositeElement',
+        'Ext.TaskManager',
+        'Ext.layout.component.ProgressBar'
+    ],
+
+    uses: ['Ext.fx.Anim'],
+
+   
+
+   
+
+   
+
+   
+    baseCls: Ext.baseCSSPrefix + 'progress',
+
+    
+    animate: false,
+
+    
+    text: '',
+
+    
+    waitTimer: null,
+
+    childEls: [
+        'bar'
+    ],
+
+    renderTpl: [
+        '<tpl if="internalText">',
+            '<div class="{baseCls}-text {baseCls}-text-back">{text}</div>',
+        '</tpl>',
+        '<div id="{id}-bar" class="{baseCls}-bar" style="width:{percentage}%">',
+            '<tpl if="internalText">',
+                '<div class="{baseCls}-text">',
+                    '<div>{text}</div>',
+                '</div>',
+            '</tpl>',
+        '</div>'
+    ],
+
+    componentLayout: 'progressbar',
+
+    
+    initComponent: function() {
+        this.callParent();
+
+        this.addEvents(
+            
+            "update"
+        );
+    },
+
+    initRenderData: function() {
+        var me = this;
+        return Ext.apply(me.callParent(), {
+            internalText : !me.hasOwnProperty('textEl'),
+            text         : me.text || '&#160;',
+            percentage   : me.value ? me.value * 100 : 0
+        });
+    },
+
+    onRender : function() {
+        var me = this;
+
+        me.callParent(arguments);
+
+        
+        if (me.textEl) {
+            me.textEl = Ext.get(me.textEl);
+            me.updateText(me.text);
+        }
+        
+        else {
+            
+            
+            me.textEl = me.el.select('.' + me.baseCls + '-text');
+        }
+    },
+
+    
+    updateProgress: function(value, text, animate) {
+        var me = this,
+            oldValue = me.value;
+
+        me.value = value || 0;
+        if (text) {
+            me.updateText(text);
+        }
+        if (me.rendered && !me.isDestroyed) {
+            if (animate === true || (animate !== false && me.animate)) {
+                me.bar.stopAnimation();
+                me.bar.animate(Ext.apply({
+                    from: {
+                        width: (oldValue * 100) + '%'
+                    },
+                    to: {
+                        width: (me.value * 100) + '%'
+                    }
+                }, me.animate));
+            } else {
+                me.bar.setStyle('width', (me.value * 100) + '%');
+            }
+        }
+        me.fireEvent('update', me, me.value, text);
+        return me;
+    },
+
+    
+    updateText: function(text) {
+        var me = this;
+        
+        me.text = text;
+        if (me.rendered) {
+            me.textEl.update(me.text);
+        }
+        return me;
+    },
+
+    applyText : function(text) {
+        this.updateText(text);
+    },
+    
+    getText: function(){
+        return this.text;    
+    },
+
+    
+    wait: function(o) {
+        var me = this, scope;
+            
+        if (!me.waitTimer) {
+            scope = me;
+            o = o || {};
+            me.updateText(o.text);
+            me.waitTimer = Ext.TaskManager.start({
+                run: function(i){
+                    var inc = o.increment || 10;
+                    i -= 1;
+                    me.updateProgress(((((i+inc)%inc)+1)*(100/inc))*0.01, null, o.animate);
+                },
+                interval: o.interval || 1000,
+                duration: o.duration,
+                onStop: function(){
+                    if (o.fn) {
+                        o.fn.apply(o.scope || me);
+                    }
+                    me.reset();
+                },
+                scope: scope
+            });
+        }
+        return me;
+    },
+
+    
+    isWaiting: function(){
+        return this.waitTimer !== null;
+    },
+
+    
+    reset: function(hide){
+        var me = this;
+        
+        me.updateProgress(0);
+        me.clearTimer();
+        if (hide === true) {
+            me.hide();
+        }
+        return me;
+    },
+
+    
+    clearTimer: function(){
+        var me = this;
+        
+        if (me.waitTimer) {
+            me.waitTimer.onStop = null; 
+            Ext.TaskManager.stop(me.waitTimer);
+            me.waitTimer = null;
+        }
+    },
+
+    onDestroy: function(){
+        var me = this;
+        
+        me.clearTimer();
+        if (me.rendered) {
+            if (me.textEl.isComposite) {
+                me.textEl.clear();
+            }
+            Ext.destroyMembers(me, 'textEl', 'progressBar');
+        }
+        me.callParent();
+    }
+});
+
+
+Ext.define('Ext.ShadowPool', {
+    singleton: true,
+    requires: ['Ext.DomHelper'],
+
+    markup: (function() {
+        return Ext.String.format(
+            '<div class="{0}{1}-shadow" role="presentation"></div>',
+            Ext.baseCSSPrefix,
+            Ext.isIE && !Ext.supports.CSS3BoxShadow ? 'ie' : 'css'
+        );
+    }()),
+
+    shadows: [],
+
+    pull: function() {
+        var sh = this.shadows.shift();
+        if (!sh) {
+            sh = Ext.get(Ext.DomHelper.insertHtml("beforeBegin", document.body.firstChild, this.markup));
+            sh.autoBoxAdjust = false;
+        }
+        return sh;
+    },
+
+    push: function(sh) {
+        this.shadows.push(sh);
+    },
+    
+    reset: function() {
+        var shadows = [].concat(this.shadows),
+            s,
+            sLen    = shadows.length;
+
+        for (s = 0; s < sLen; s++) {
+            shadows[s].remove();
+        }
+
+        this.shadows = [];
+    }
+});
+
+
+Ext.define('Ext.Shadow', {
+    requires: ['Ext.ShadowPool'],
+
+    
+    constructor: function(config) {
+        var me = this,
+            adjusts,
+            offset,
+            rad;
+        
+        Ext.apply(me, config);
+        if (!Ext.isString(me.mode)) {
+            me.mode = me.defaultMode;
+        }
+        offset = me.offset;
+        rad = Math.floor(offset / 2);
+        me.opacity = 50;
+        switch (me.mode.toLowerCase()) {
+            
+            case "drop":
+                if (Ext.supports.CSS3BoxShadow) {
+                    adjusts = {
+                        t: offset,
+                        l: offset,
+                        h: -offset,
+                        w: -offset
+                    };
+                }
+                else {
+                    adjusts = {
+                        t: -rad,
+                        l: -rad,
+                        h: -rad,
+                        w: -rad
+                    };
+                }
+                break;
+            case "sides":
+                if (Ext.supports.CSS3BoxShadow) {
+                    adjusts = {
+                        t: offset,
+                        l: 0,
+                        h: -offset,
+                        w: 0
+                    };
+                }
+                else {
+                    adjusts = {
+                        t: - (1 + rad),
+                        l: 1 + rad - 2 * offset,
+                        h: -1,
+                        w: rad - 1
+                    };
+                }
+                break;
+            case "frame":
+                if (Ext.supports.CSS3BoxShadow) {
+                    adjusts = {
+                        t: 0,
+                        l: 0,
+                        h: 0,
+                        w: 0
+                    };
+                }
+                else {
+                    adjusts = {
+                        t: 1 + rad - 2 * offset,
+                        l: 1 + rad - 2 * offset,
+                        h: offset - rad - 1,
+                        w: offset - rad - 1
+                    };
+                }
+                break;
+        }
+        me.adjusts = adjusts;
+    },
+
+    
+    getShadowSize: function() {
+        var me = this,
+            offset = me.el ? me.offset : 0,
+            result = [offset, offset, offset, offset],
+            mode = me.mode.toLowerCase();
+
+        
+        if (me.el && mode !== 'frame') {
+            result[0] = 0;
+            if (mode == 'drop') {
+                result[3] = 0;
+            }
+        }
+        return result;
+    },
+
+    
+
+    
+    offset: 4,
+
+    
+    defaultMode: "drop",
+
+    
+    boxShadowProperty: (function() {
+        var property = 'boxShadow',
+            style = document.documentElement.style;
+
+        if (!('boxShadow' in style)) {
+            if ('WebkitBoxShadow' in style) {
+                
+                property = 'WebkitBoxShadow';
+            }
+            else if ('MozBoxShadow' in style) {
+                
+                property = 'MozBoxShadow';
+            }
+        }
+
+        return property;
+    }()),
+
+    
+    show: function(target) {
+        var me = this,
+            index;
+        
+        target = Ext.get(target);
+        if (!me.el) {
+            me.el = Ext.ShadowPool.pull();
+            if (me.el.dom.nextSibling != target.dom) {
+                me.el.insertBefore(target);
+            }
+        }
+        index = (parseInt(target.getStyle("z-index"), 10) - 1) || 0;
+        me.el.setStyle("z-index", me.zIndex || index);
+        if (Ext.isIE && !Ext.supports.CSS3BoxShadow) {
+            me.el.dom.style.filter = "progid:DXImageTransform.Microsoft.alpha(opacity=" + me.opacity + ") progid:DXImageTransform.Microsoft.Blur(pixelradius=" + (me.offset) + ")";
+        }
+        me.realign(
+            target.getLocalX(),
+            target.getLocalY(),
+            target.dom.offsetWidth,
+            target.dom.offsetHeight
+        );
+        me.el.dom.style.display = "block";
+    },
+
+    
+    isVisible: function() {
+        return this.el ? true: false;
+    },
+
+    
+    realign: function(l, t, targetWidth, targetHeight) {
+        if (!this.el) {
+            return;
+        }
+        var adjusts = this.adjusts,
+            d = this.el.dom,
+            targetStyle = d.style,
+            shadowWidth,
+            shadowHeight,
+            sws,
+            shs;
+
+        targetStyle.left = (l + adjusts.l) + "px";
+        targetStyle.top = (t + adjusts.t) + "px";
+        shadowWidth = Math.max(targetWidth + adjusts.w, 0);
+        shadowHeight = Math.max(targetHeight + adjusts.h, 0);
+        sws = shadowWidth + "px";
+        shs = shadowHeight + "px";
+        if (targetStyle.width != sws || targetStyle.height != shs) {
+            targetStyle.width = sws;
+            targetStyle.height = shs;
+
+            if (Ext.supports.CSS3BoxShadow) {
+                targetStyle[this.boxShadowProperty] = '0 0 ' + this.offset + 'px #888';
+            }
+        }
+    },
+
+    
+    hide: function() {
+        var me = this;
+        
+        if (me.el) {
+            me.el.dom.style.display = "none";
+            Ext.ShadowPool.push(me.el);
+            delete me.el;
+        }
+    },
+
+    
+    setZIndex: function(z) {
+        this.zIndex = z;
+        if (this.el) {
+            this.el.setStyle("z-index", z);
+        }
+    },
+    
+    
+    setOpacity: function(opacity){
+        if (this.el) {
+            if (Ext.isIE && !Ext.supports.CSS3BoxShadow) {
+                opacity = Math.floor(opacity * 100 / 2) / 100;
+            }
+            this.opacity = opacity;
+            this.el.setOpacity(opacity);
+        }
+    }
+});
+
+
+Ext.define('Ext.app.Controller', {
+
+    mixins: {
+        observable: 'Ext.util.Observable'
+    },
+
+    
+    
+    
+
+    
+
+    
+
+    
+
+    onClassExtended: function(cls, data, hooks) {
+        var className = Ext.getClassName(cls),
+            match = className.match(/^(.*)\.controller\./),
+            namespace,
+            onBeforeClassCreated,
+            requires,
+            modules,
+            namespaceAndModule;
+        
+        if (match !== null) {
+            namespace = Ext.Loader.getPrefix(className) || match[1];
+            onBeforeClassCreated = hooks.onBeforeCreated;
+            requires = [];
+            modules = ['model', 'view', 'store'];
+
+            hooks.onBeforeCreated = function(cls, data) {
+                var i, ln, module,
+                    items, j, subLn, item;
+
+                for (i = 0,ln = modules.length; i < ln; i++) {
+                    module = modules[i];
+                    namespaceAndModule = namespace + '.' + module + '.';
+
+                    items = Ext.Array.from(data[module + 's']);
+
+                    for (j = 0,subLn = items.length; j < subLn; j++) {
+                        item = items[j];
+                        
+                        
+                        
+                        
+                        
+                        
+                        
+                        if (item.indexOf('.') !== -1 && (Ext.ClassManager.isCreated(item) || Ext.Loader.isAClassNameWithAKnownPrefix(item))) {
+                            requires.push(item);
+                        } else {
+                            requires.push(namespaceAndModule + item);
+                        }
+                    }
+                }
+
+                Ext.require(requires, Ext.Function.pass(onBeforeClassCreated, arguments, this));
+            };
+        }
+    },
+
+    
+    constructor: function(config) {
+        this.mixins.observable.constructor.call(this, config);
+
+        Ext.apply(this, config || {});
+        this.createGetters('model', this.models);
+        this.createGetters('store', this.stores);
+        this.createGetters('view', this.views);
+
+        if (this.refs) {
+            this.ref(this.refs);
+        }
+    },
+
+    
+    init: Ext.emptyFn,
+
+    
+    onLaunch: Ext.emptyFn,
+
+    createGetters: function(type, refs) {
+        type = Ext.String.capitalize(type);
+
+        var i      = 0,
+            length = (refs) ? refs.length : 0,
+            fn, ref, parts, x, numParts;
+
+        for (; i < length; i++) {
+            fn    = 'get';
+            ref   = refs[i];
+            parts = ref.split('.');
+            numParts = parts.length;
+
+            
+            for (x = 0 ; x < numParts; x++) {
+                fn += Ext.String.capitalize(parts[x]);
+            }
+
+            fn += type;
+
+            if (!this[fn]) {
+                this[fn] = Ext.Function.pass(this['get' + type], [ref], this);
+            }
+            
+            this[fn](ref);
+        }
+    },
+
+    ref: function(refs) {
+        refs = Ext.Array.from(refs);
+        
+        var me = this,
+            i = 0,
+            length = refs.length,
+            info, ref, fn;
+        
+        me.references = me.references || [];
+
+        for (; i < length; i++) {
+            info = refs[i];
+            ref  = info.ref;
+            fn   = 'get' + Ext.String.capitalize(ref);
+
+            if (!me[fn]) {
+                me[fn] = Ext.Function.pass(me.getRef, [ref, info], me);
+            }
+            me.references.push(ref.toLowerCase());
+        }
+    },
+
+    
+    addRef: function(ref) {
+        return this.ref([ref]);
+    },
+
+    getRef: function(ref, info, config) {
+        this.refCache = this.refCache || {};
+        info = info || {};
+        config = config || {};
+
+        Ext.apply(info, config);
+
+        if (info.forceCreate) {
+            return Ext.ComponentManager.create(info, 'component');
+        }
+
+        var me = this,
+            cached = me.refCache[ref];
+
+        if (!cached) {
+            me.refCache[ref] = cached = Ext.ComponentQuery.query(info.selector)[0];
+            if (!cached && info.autoCreate) {
+                me.refCache[ref] = cached = Ext.ComponentManager.create(info, 'component');
+            }
+            if (cached) {
+                cached.on('beforedestroy', function() {
+                    me.refCache[ref] = null;
+                });
+            }
+        }
+
+        return cached;
+    },
+
+    
+    hasRef: function(ref) {
+        return this.references && this.references.indexOf(ref.toLowerCase()) !== -1;
+    },
+
+    
+    control: function(selectors, listeners) {
+        this.application.control(selectors, listeners, this);
+    },
+
+    
+    getController: function(name) {
+        return this.application.getController(name);
+    },
+
+    
+    getStore: function(name) {
+        return this.application.getStore(name);
+    },
+
+    
+    getModel: function(model) {
+        return this.application.getModel(model);
+    },
+
+    
+    getView: function(view) {
+        return this.application.getView(view);
+    }
+});
+
+
+Ext.define('Ext.data.IdGenerator', {
+
+    
+    isGenerator: true,
+
+    
+    constructor: function(config) {
+        var me = this;
+
+        Ext.apply(me, config);
+
+        if (me.id) {
+            Ext.data.IdGenerator.all[me.id] = me;
+        }
+    },
+
+    
+
+    getRecId: function (rec) {
+        return rec.modelName + '-' + rec.internalId;
+    },
+
+    
+
+    statics: {
+        
+        all: {},
+
+        
+        get: function (config) {
+            var generator,
+                id,
+                type;
+
+            if (typeof config == 'string') {
+                id = type = config;
+                config = null;
+            } else if (config.isGenerator) {
+                return config;
+            } else {
+                id = config.id || config.type;
+                type = config.type;
+            }
+
+            generator = this.all[id];
+            if (!generator) {
+                generator = Ext.create('idgen.' + type, config);
+            }
+
+            return generator;
+        }
+    }
+});
+
+
+Ext.define('Ext.data.SortTypes', {
+    
+    singleton: true,
+    
+    
+    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, ""));
+        return isNaN(val) ? 0 : val;
+    },
+
+    
+    asInt : function(s) {
+        var val = parseInt(String(s).replace(/,/g, ""), 10);
+        return isNaN(val) ? 0 : val;
+    }
+});
+
+
+Ext.define('Ext.data.Types', {
+    singleton: true,
+    requires: ['Ext.data.SortTypes']
+}, function() {
+    var st = Ext.data.SortTypes;
+
+    Ext.apply(Ext.data.Types, {
+        
+        stripRe: /[\$,%]/g,
+
+        
+        AUTO: {
+            sortType: st.none,
+            type: 'auto'
+        },
+
+        
+        STRING: {
+            convert: function(v) {
+                var defaultValue = this.useNull ? null : '';
+                return (v === undefined || v === null) ? defaultValue : String(v);
+            },
+            sortType: st.asUCString,
+            type: 'string'
+        },
+
+        
+        INT: {
+            convert: function(v) {
+                return v !== undefined && v !== null && v !== '' ?
+                    parseInt(String(v).replace(Ext.data.Types.stripRe, ''), 10) : (this.useNull ? null : 0);
+            },
+            sortType: st.none,
+            type: 'int'
+        },
+
+        
+        FLOAT: {
+            convert: function(v) {
+                return v !== undefined && v !== null && v !== '' ?
+                    parseFloat(String(v).replace(Ext.data.Types.stripRe, ''), 10) : (this.useNull ? null : 0);
+            },
+            sortType: st.none,
+            type: 'float'
+        },
+
+        
+        BOOL: {
+            convert: function(v) {
+                if (this.useNull && (v === undefined || v === null || v === '')) {
+                    return null;
+                }
+                return v === true || v === 'true' || v == 1;
+            },
+            sortType: st.none,
+            type: 'bool'
+        },
+
+        
+        DATE: {
+            convert: function(v) {
+                var df = this.dateFormat,
+                    parsed;
+
+                if (!v) {
+                    return null;
+                }
+                if (Ext.isDate(v)) {
+                    return v;
+                }
+                if (df) {
+                    if (df == 'timestamp') {
+                        return new Date(v*1000);
+                    }
+                    if (df == 'time') {
+                        return new Date(parseInt(v, 10));
+                    }
+                    return Ext.Date.parse(v, df);
+                }
+
+                parsed = Date.parse(v);
+                return parsed ? new Date(parsed) : null;
+            },
+            sortType: st.asDate,
+            type: 'date'
+        }
+    });
+
+    Ext.apply(Ext.data.Types, {
+        
+        BOOLEAN: this.BOOL,
+
+        
+        INTEGER: this.INT,
+
+        
+        NUMBER: this.FLOAT
+    });
+});
+
+
+Ext.define('Ext.data.Field', {
+    requires: ['Ext.data.Types', 'Ext.data.SortTypes'],
+    alias: 'data.field',
+
+    isField: true,
+    
+    constructor : function(config) {
+        var me = this,
+            types = Ext.data.Types,
+            st;
+        
+        if (Ext.isString(config)) {
+            config = {name: config};
+        }
+        Ext.apply(me, config);
+
+        st = me.sortType;
+
+        if (me.type) {
+            if (Ext.isString(me.type)) {
+                me.type = types[me.type.toUpperCase()] || types.AUTO;
+            }
+        } else {
+            me.type = types.AUTO;
+        }
+
+        
+        if (Ext.isString(st)) {
+            me.sortType = Ext.data.SortTypes[st];
+        } else if(Ext.isEmpty(st)) {
+            me.sortType = me.type.sortType;
+        }
+
+        
+        if (!config.hasOwnProperty('convert')) {
+            me.convert = me.type.convert; 
+        } else if (!me.convert && me.type.convert && !config.hasOwnProperty('defaultValue')) {
+            
+            
+            me.defaultValue = me.type.convert(me.defaultValue);
+        }
+
+        if (config.convert) {
+            me.hasCustomConvert = true;
+        }
+    },
+    
+    
+    
+    
+
+    
+
+    
+
+    
+    dateFormat: null,
+    
+    
+    useNull: false,
+    
+    
+    defaultValue: "",
+
+    
+    mapping: null,
+
+    
+    sortType : null,
+
+    
+    sortDir : "ASC",
+
+    
+    allowBlank : true,
+
+    
+    persist: true
+});
+
+
+Ext.define('Ext.data.Errors', {
+    extend: 'Ext.util.MixedCollection',
+
+    
+    isValid: function() {
+        return this.length === 0;
+    },
+
+    
+    getByField: function(fieldName) {
+        var errors = [],
+            error, field, i;
+
+        for (i = 0; i < this.length; i++) {
+            error = this.items[i];
+
+            if (error.field == fieldName) {
+                errors.push(error);
+            }
+        }
+
+        return errors;
+    }
+});
+
+
+Ext.define('Ext.data.Operation', {
+    
+    synchronous: true,
+
+    
+    action: undefined,
+
+    
+    filters: undefined,
+
+    
+    sorters: undefined,
+
+    
+    groupers: undefined,
+
+    
+    start: undefined,
+
+    
+    limit: undefined,
+
+    
+    batch: undefined,
+    
+    
+
+    
+    callback: undefined,
+
+    
+    scope: undefined,
+
+    
+    started: false,
+
+    
+    running: false,
+
+    
+    complete: false,
+
+    
+    success: undefined,
+
+    
+    exception: false,
+
+    
+    error: undefined,
+
+    
+    actionCommitRecordsRe: /^(?:create|update)$/i,
+
+    
+    actionSkipSyncRe: /^destroy$/i,
+
+    
+    constructor: function(config) {
+        Ext.apply(this, config || {});
+    },
+
+    
+    commitRecords: function (serverRecords) {
+        var me = this,
+            mc, index, clientRecords, serverRec, clientRec, i, len;
+
+        if (!me.actionSkipSyncRe.test(me.action)) {
+            clientRecords = me.records;
+
+            if (clientRecords && clientRecords.length) {
+                if (clientRecords.length > 1) {
+                    
+                    
+                    
+                    
+                    if (me.action == 'update' || clientRecords[0].clientIdProperty) {
+                        mc = new Ext.util.MixedCollection();
+                        mc.addAll(serverRecords);
+
+                        for (index = clientRecords.length; index--; ) {
+                            clientRec = clientRecords[index];
+                            serverRec = mc.findBy(me.matchClientRec, clientRec);
+
+                            
+                            clientRec.copyFrom(serverRec);
+                        }
+                    } else {
+                        for (i = 0, len = clientRecords.length; i < len; ++i) {
+                            clientRec = clientRecords[i];
+                            serverRec = serverRecords[i];
+                            if (clientRec && serverRec) {
+                                me.updateRecord(clientRec, serverRec);
+                            }
+                        }
+                    }
+                } else {
+                    
+                    this.updateRecord(clientRecords[0], serverRecords[0]);   
+                }
+
+                if (me.actionCommitRecordsRe.test(me.action)) {
+                    for (index = clientRecords.length; index--; ) {
+                        clientRecords[index].commit();
+                    }
+                }
+            }
+        }
+    },
+    
+    updateRecord: function(clientRec, serverRec) {
+        
+        if(serverRec && (clientRec.phantom || clientRec.getId() === serverRec.getId())) {
+            clientRec.copyFrom(serverRec);
+        }
+    },
+
+    
+    
+    
+    matchClientRec: function(record) {
+        var clientRec = this,
+            clientRecordId = clientRec.getId();
+
+        if(clientRecordId && record.getId() === clientRecordId) {
+            return true;
+        }
+        
+        
+        
+        return record.internalId === clientRec.internalId;
+    },
+
+    
+    setStarted: function() {
+        this.started = true;
+        this.running = true;
+    },
+
+    
+    setCompleted: function() {
+        this.complete = true;
+        this.running  = false;
+    },
+
+    
+    setSuccessful: function() {
+        this.success = true;
+    },
+
+    
+    setException: function(error) {
+        this.exception = true;
+        this.success = false;
+        this.running = false;
+        this.error = error;
+    },
+
+    
+    hasException: function() {
+        return this.exception === true;
+    },
+
+    
+    getError: function() {
+        return this.error;
+    },
+
+    
+    getRecords: function() {
+        var resultSet = this.getResultSet();
+        return this.records || (resultSet ? resultSet.records : null);
+    },
+
+    
+    getResultSet: function() {
+        return this.resultSet;
+    },
+
+    
+    isStarted: function() {
+        return this.started === true;
+    },
+
+    
+    isRunning: function() {
+        return this.running === true;
+    },
+
+    
+    isComplete: function() {
+        return this.complete === true;
+    },
+
+    
+    wasSuccessful: function() {
+        return this.isComplete() && this.success === true;
+    },
+
+    
+    setBatch: function(batch) {
+        this.batch = batch;
+    },
+
+    
+    allowWrite: function() {
+        return this.action != 'read';
+    }
+});
+
+
+Ext.define('Ext.data.validations', {
+    singleton: true,
+    
+    
+    presenceMessage: 'must be present',
+    
+    
+    lengthMessage: 'is the wrong length',
+    
+    
+    formatMessage: 'is the wrong format',
+    
+    
+    inclusionMessage: 'is not included in the list of acceptable values',
+    
+    
+    exclusionMessage: 'is not an acceptable value',
+    
+    
+    emailMessage: 'is not a valid email address',
+    
+    
+    emailRe: /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/,
+    
+    
+    presence: function(config, value) {
+        
+        if (arguments.length === 1) {
+            value = config;
+        }
+        
+        
+        return !!value || value === 0;
+    },
+    
+    
+    length: function(config, value) {
+        if (value === undefined || value === null) {
+            return false;
+        }
+        
+        var length = value.length,
+            min    = config.min,
+            max    = config.max;
+        
+        if ((min && length < min) || (max && length > max)) {
+            return false;
+        } else {
+            return true;
+        }
+    },
+    
+    
+    email: function(config, email) {
+        return Ext.data.validations.emailRe.test(email);
+    },
+    
+    
+    format: function(config, value) {
+        return !!(config.matcher && config.matcher.test(value));
+    },
+    
+    
+    inclusion: function(config, value) {
+        return config.list && Ext.Array.indexOf(config.list,value) != -1;
+    },
+    
+    
+    exclusion: function(config, value) {
+        return config.list && Ext.Array.indexOf(config.list,value) == -1;
+    }
+});
+
+
+Ext.define('Ext.data.Model', {
+    alternateClassName: 'Ext.data.Record',
+
+    mixins: {
+        observable: 'Ext.util.Observable'
+    },
+    
+    requires: [
+        'Ext.ModelManager',
+        'Ext.data.IdGenerator',
+        'Ext.data.Field',
+        'Ext.data.Errors',
+        'Ext.data.Operation',
+        'Ext.data.validations',
+        'Ext.util.MixedCollection'
+    ],
+
+    compareConvertFields: function(f1, f2) {
+        var f1SpecialConvert = f1.convert && f1.type && f1.convert !== f1.type.convert,
+            f2SpecialConvert = f2.convert && f2.type && f2.convert !== f2.type.convert;
+
+        if (f1SpecialConvert && !f2SpecialConvert) {
+            return 1;
+        }
+
+        if (!f1SpecialConvert && f2SpecialConvert) {
+            return -1;
+        }
+        return 0;
+    },
+
+    itemNameFn: function(item) {
+        return item.name;
+    },
+
+    onClassExtended: function(cls, data, hooks) {
+        var onBeforeClassCreated = hooks.onBeforeCreated;
+
+        hooks.onBeforeCreated = function(cls, data) {
+            var me = this,
+                name = Ext.getClassName(cls),
+                prototype = cls.prototype,
+                superCls = cls.prototype.superclass,
+
+                validations = data.validations || [],
+                fields = data.fields || [],
+                field,
+                associationsConfigs = data.associations || [],
+                addAssociations = function(items, type) {
+                    var i = 0,
+                        len,
+                        item;
+
+                    if (items) {
+                        items = Ext.Array.from(items);
+
+                        for (len = items.length; i < len; ++i) {
+                            item = items[i];
+
+                            if (!Ext.isObject(item)) {
+                                item = {model: item};
+                            }
+
+                            item.type = type;
+                            associationsConfigs.push(item);
+                        }
+                    }
+                },
+                idgen = data.idgen,
+
+                fieldsMixedCollection = new Ext.util.MixedCollection(false, prototype.itemNameFn),
+
+                associationsMixedCollection = new Ext.util.MixedCollection(false, prototype.itemNameFn),
+
+                superValidations = superCls.validations,
+                superFields = superCls.fields,
+                superAssociations = superCls.associations,
+
+                associationConfig, i, ln,
+                dependencies = [],
+                idProperty = data.idProperty || cls.prototype.idProperty,
+
+                
+                onFieldAddReplace = function(arg0, arg1, arg2) {
+                    var newField,
+                        pos;
+
+                    if (fieldsMixedCollection.events.add.firing) {
+                        
+                        pos = arg0;
+                        newField  = arg1;
+                    } else {
+                        
+                        newField = arg2;
+                        pos = arg1.originalIndex;
+                    }
+
+                    
+                    
+                    newField.originalIndex = pos;
+
+                    
+                    
+                    
+                    if (newField.mapping === idProperty || (newField.mapping == null && newField.name === idProperty)) {
+                        newField.defaultValue = undefined;
+                    }
+                },
+
+                
+                clsProxy = data.proxy || cls.prototype.proxy || cls.prototype.defaultProxyType,
+
+                
+                fieldConvertSortFn = function() {
+                    fieldsMixedCollection.sortBy(prototype.compareConvertFields);
+                };
+
+            
+            cls.modelName = name;
+            prototype.modelName = name;
+
+            
+            if (superValidations) {
+                validations = superValidations.concat(validations);
+            }
+
+            data.validations = validations;
+
+            
+            if (superFields) {
+                fields = superFields.items.concat(fields);
+            }
+
+            fieldsMixedCollection.on({
+                add:     onFieldAddReplace,
+                replace: onFieldAddReplace
+            });  
+
+            for (i = 0, ln = fields.length; i < ln; ++i) {
+                field = fields[i];
+                fieldsMixedCollection.add(field.isField ? field : new Ext.data.Field(field));
+            }
+            if (!fieldsMixedCollection.get(idProperty)) {
+                fieldsMixedCollection.add(new Ext.data.Field(idProperty));
+            }
+
+            
+            fieldConvertSortFn();
+            fieldsMixedCollection.on({
+                add:     fieldConvertSortFn,
+                replace: fieldConvertSortFn
+            });
+
+            data.fields = fieldsMixedCollection;
+
+            if (idgen) {
+                data.idgen = Ext.data.IdGenerator.get(idgen);
+            }
+
+            
+            
+            addAssociations(data.belongsTo, 'belongsTo');
+            delete data.belongsTo;
+            addAssociations(data.hasMany, 'hasMany');
+            delete data.hasMany;
+            addAssociations(data.hasOne, 'hasOne');
+            delete data.hasOne;
+
+            if (superAssociations) {
+                associationsConfigs = superAssociations.items.concat(associationsConfigs);
+            }
+
+            for (i = 0, ln = associationsConfigs.length; i < ln; ++i) {
+                dependencies.push('association.' + associationsConfigs[i].type.toLowerCase());
+            }
+
+            
+            if (clsProxy && !clsProxy.isProxy) {
+
+                dependencies.push('proxy.' + (typeof clsProxy === 'string' ? clsProxy : clsProxy.type));
+            }
+
+            Ext.require(dependencies, function() {
+                Ext.ModelManager.registerType(name, cls);
+
+                for (i = 0, ln = associationsConfigs.length; i < ln; ++i) {
+                    associationConfig = associationsConfigs[i];
+                    if (associationConfig.isAssociation) {
+                        associationConfig = Ext.applyIf({
+                            ownerModel: name,
+                            associatedModel: associationConfig.model
+                        }, associationConfig.initialConfig);
+                    } else {
+                        Ext.apply(associationConfig, {
+                            ownerModel: name,
+                            associatedModel: associationConfig.model
+                        });
+                    }
+
+                    if (Ext.ModelManager.getModel(associationConfig.model) === undefined) {
+                        Ext.ModelManager.registerDeferredAssociation(associationConfig);
+                    } else {
+                        associationsMixedCollection.add(Ext.data.association.Association.create(associationConfig));
+                    }
+                }
+
+                data.associations = associationsMixedCollection;
+
+                
+                
+                
+                
+                
+                onBeforeClassCreated.call(me, cls, data, hooks);
+
+                cls.setProxy(clsProxy);
+
+                
+                Ext.ModelManager.onModelDefined(cls);
+            });
+        };
+    },
+
+    inheritableStatics: {
+        
+        setProxy: function(proxy) {
+            
+            if (!proxy.isProxy) {
+                if (typeof proxy == "string") {
+                    proxy = {
+                        type: proxy
+                    };
+                }
+                proxy = Ext.createByAlias("proxy." + proxy.type, proxy);
+            }
+            proxy.setModel(this);
+            this.proxy = this.prototype.proxy = proxy;
+
+            return proxy;
+        },
+
+        
+        getProxy: function() {
+            return this.proxy;
+        },
+
+        
+        setFields: function(fields, idProperty, clientIdProperty) {
+            var me = this,
+                proto = me.prototype,
+                prototypeFields = proto.fields,
+                len = fields ? fields.length : 0,
+                i = 0;
+
+
+            if (idProperty) {
+                proto.idProperty = idProperty;
+            }
+            if (clientIdProperty) {
+                proto.clientIdProperty = clientIdProperty;
+            }
+
+            if (prototypeFields) {
+                prototypeFields.clear();
+            }
+            else {
+                prototypeFields = me.prototype.fields = new Ext.util.MixedCollection(false, function(field) {
+                    return field.name;
+                });
+            }
+
+            for (; i < len; i++) {
+                prototypeFields.add(new Ext.data.Field(fields[i]));
+            }
+            if (!prototypeFields.get(proto.idProperty)) {
+                prototypeFields.add(new Ext.data.Field(proto.idProperty));
+            }
+
+            me.fields = prototypeFields;
+
+            return prototypeFields;
+        },
+
+        
+        getFields: function() {
+            return this.prototype.fields.items;
+        },
+
+        
+        load: function(id, config) {
+            config = Ext.apply({}, config);
+            config = Ext.applyIf(config, {
+                action: 'read',
+                id    : id
+            });
+
+            var operation  = new Ext.data.Operation(config),
+                scope      = config.scope || this,
+                record     = null,
+                callback;
+
+            callback = function(operation) {
+                if (operation.wasSuccessful()) {
+                    record = operation.getRecords()[0];
+                    Ext.callback(config.success, scope, [record, operation]);
+                } else {
+                    Ext.callback(config.failure, scope, [record, operation]);
+                }
+                Ext.callback(config.callback, scope, [record, operation]);
+            };
+
+            this.proxy.read(operation, callback, this);
+        }
+    },
+
+    statics: {
+        
+        PREFIX : 'ext-record',
+        
+        AUTO_ID: 1,
+        
+        EDIT   : 'edit',
+        
+        REJECT : 'reject',
+        
+        COMMIT : 'commit',
+
+        
+        id: function(rec) {
+            var id = [this.PREFIX, '-', this.AUTO_ID++].join('');
+            rec.phantom = true;
+            rec.internalId = id;
+            return id;
+        }
+    },
+
+    
+    idgen: {
+        isGenerator: true,
+        type: 'default',
+
+        generate: function () {
+            return null;
+        },
+        getRecId: function (rec) {
+            return rec.modelName + '-' + rec.internalId;
+        }
+    },
+
+    
+    editing : false,
+
+    
+    dirty : false,
+
+    
+    persistenceProperty: 'data',
+
+    evented: false,
+
+    
+    isModel: true,
+
+    
+    phantom : false,
+
+    
+    idProperty: 'id',
+
+    
+    clientIdProperty: null,
+
+    
+    defaultProxyType: 'ajax',
+
+    
+    
+    
+
+    
+
+    
+    
+    
+    
+    
+
+    
+
+    
+    constructor: function(data, id, raw, convertedData) {
+        
+        
+        
+        
+        data = data || {};
+
+        var me = this,
+            fields,
+            length,
+            field,
+            name,
+            value,
+            newId,
+            persistenceProperty,
+            i;
+
+
+        
+        me.internalId = (id || id === 0) ? id : Ext.data.Model.id(me);
+
+        
+        me.raw = raw || data; 
+
+        if (!me.data) {
+            me.data = {};
+        }
+
+        
+        me.modified = {};
+
+        
+        if (me.persistanceProperty) {
+            me.persistenceProperty = me.persistanceProperty;
+        }
+
+        me[me.persistenceProperty] = convertedData || {};
+
+        me.mixins.observable.constructor.call(me);
+
+        if (!convertedData) {
+            
+            fields = me.fields.items;
+            length = fields.length;
+            i = 0;
+            persistenceProperty = me[me.persistenceProperty];
+
+            if (Ext.isArray(data)) {
+                for (; i < length; i++) {
+                    field = fields[i];
+                    name  = field.name;
+
+                    
+                    
+                    value = data[field.originalIndex];
+
+                    if (value === undefined) {
+                        value = field.defaultValue;
+                    }
+                    
+                    
+                    if (field.convert) {
+                        value = field.convert(value, me);
+                    }
+                    
+                    if (value !== undefined) {
+                        persistenceProperty[name] = value;
+                    }
+                }
+
+            } else {
+               for (; i < length; i++) {
+                    field = fields[i];
+                    name  = field.name;
+                    value = data[name];
+                    if (value === undefined) {
+                        value = field.defaultValue;
+                    }
+                    if (field.convert) {
+                        value = field.convert(value, me);
+                    }
+                    
+                    if (value !== undefined) {
+                        persistenceProperty[name] = value;
+                    }
+               }
+            }
+        }
+
+        
+        me.stores = [];
+
+        if (me.getId()) {
+            me.phantom = false;
+        } else if (me.phantom) {
+            newId = me.idgen.generate();
+            if (newId !== null) {
+                me.setId(newId);
+            }
+        }
+
+        
+        me.dirty = false;
+        me.modified = {};
+
+        if (typeof me.init == 'function') {
+            me.init();
+        }
+
+        me.id = me.idgen.getRecId(me);
+    },
+
+    
+    get: function(field) {
+        return this[this.persistenceProperty][field];
+    },
+
+    
+    
+    
+    _singleProp: {},
+
+    
+    set: function (fieldName, newValue) {
+        var me = this,
+            data = me[me.persistenceProperty],
+            fields = me.fields,
+            modified = me.modified,
+            single = (typeof fieldName == 'string'),
+            currentValue, field, idChanged, key, modifiedFieldNames, name, oldId,
+            newId, value, values;
+
+        if (single) {
+            values = me._singleProp;
+            values[fieldName] = newValue;
+        } else {
+            values = fieldName;
+        }
+
+        for (name in values) {
+            if (values.hasOwnProperty(name)) {
+                value = values[name];
+
+                if (fields && (field = fields.get(name)) && field.convert) {
+                    value = field.convert(value, me);
+                }
+
+                currentValue = data[name];
+                if (me.isEqual(currentValue, value)) {
+                    continue; 
+                }
+
+                data[name] = value;
+                (modifiedFieldNames || (modifiedFieldNames = [])).push(name);
+
+                if (field && field.persist) {
+                    if (modified.hasOwnProperty(name)) {
+                        if (me.isEqual(modified[name], value)) {
+                            
+                            
+                            delete modified[name];
+
+                            
+                            
+                            
+                            me.dirty = false;
+                            for (key in modified) {
+                                if (modified.hasOwnProperty(key)){
+                                    me.dirty = true;
+                                    break;
+                                }
+                            }
+                        }
+                    } else {
+                        me.dirty = true;
+                        modified[name] = currentValue;
+                    }
+                }
+
+                if (name == me.idProperty) {
+                    idChanged = true;
+                    oldId = currentValue;
+                    newId = value;
+                }
+            }
+        }
+
+        if (single) {
+            
+            
+            delete values[fieldName];
+        }
+
+        if (idChanged) {
+            me.fireEvent('idchanged', me, oldId, newId);
+        }
+
+        if (!me.editing && modifiedFieldNames) {
+            me.afterEdit(modifiedFieldNames);
+        }
+
+        return modifiedFieldNames || null;
+    },
+
+    
+    copyFrom: function(sourceRecord) {
+        if (sourceRecord) {
+
+            var me = this,
+                fields = me.fields.items,
+                fieldCount = fields.length,
+                field, i = 0,
+                myData = me[me.persistenceProperty],
+                sourceData = sourceRecord[sourceRecord.persistenceProperty],
+                value;
+
+            for (; i < fieldCount; i++) {
+                field = fields[i];
+
+                
+                
+                
+                
+                
+                value = sourceData[field.name];
+                if (value !== undefined) {
+                    myData[field.name] = value;
+                }
+            }
+
+            
+            if (me.phantom && !sourceRecord.phantom) {
+                me.setId(sourceRecord.getId());
+            }
+        }
+    },
+
+    
+    isEqual: function(a, b){
+        if (Ext.isDate(a) && Ext.isDate(b)) {
+            return Ext.Date.isEqual(a, b);
+        }
+        return a === b;
+    },
+
+    
+    beginEdit : function(){
+        var me = this;
+        if (!me.editing) {
+            me.editing = true;
+            me.dirtySave = me.dirty;
+            me.dataSave = Ext.apply({}, me[me.persistenceProperty]);
+            me.modifiedSave = Ext.apply({}, me.modified);
+        }
+    },
+
+    
+    cancelEdit : function(){
+        var me = this;
+        if (me.editing) {
+            me.editing = false;
+            
+            me.modified = me.modifiedSave;
+            me[me.persistenceProperty] = me.dataSave;
+            me.dirty = me.dirtySave;
+            delete me.modifiedSave;
+            delete me.dataSave;
+            delete me.dirtySave;
+        }
+    },
+
+    
+    endEdit : function(silent, modifiedFieldNames){
+        var me = this,
+            changed;
+        if (me.editing) {
+            me.editing = false;
+            if(!modifiedFieldNames) {
+                modifiedFieldNames = me.getModifiedFieldNames();
+            }
+            changed = me.dirty || modifiedFieldNames.length > 0;
+            delete me.modifiedSave;
+            delete me.dataSave;
+            delete me.dirtySave;
+            if (changed && silent !== true) {
+                me.afterEdit(modifiedFieldNames);
+            }
+        }
+    },
+
+    
+    getModifiedFieldNames: function(){
+        var me = this,
+            saved = me.dataSave,
+            data = me[me.persistenceProperty],
+            modified = [],
+            key;
+
+        for (key in data) {
+            if (data.hasOwnProperty(key)) {
+                if (!me.isEqual(data[key], saved[key])) {
+                    modified.push(key);
+                }
+            }
+        }
+        return modified; 
+    },
+
+    
+    getChanges : function(){
+        var modified = this.modified,
+            changes  = {},
+            field;
+
+        for (field in modified) {
+            if (modified.hasOwnProperty(field)){
+                changes[field] = this.get(field);
+            }
+        }
+
+        return changes;
+    },
+
+    
+    isModified : function(fieldName) {
+        return this.modified.hasOwnProperty(fieldName);
+    },
+
+    
+    setDirty : function() {
+        var me     = this,
+            fields = me.fields.items,
+            fLen   = fields.length,
+            field, name, f;
+
+        me.dirty = true;
+
+        for (f = 0; f < fLen; f++) {
+            field = fields[f];
+
+            if (field.persist) {
+                name  = field.name;
+                me.modified[name] = me.get(name);
+            }
+        }
+    },
+
+
+    
+    reject : function(silent) {
+        var me = this,
+            modified = me.modified,
+            field;
+
+        for (field in modified) {
+            if (modified.hasOwnProperty(field)) {
+                if (typeof modified[field] != "function") {
+                    me[me.persistenceProperty][field] = modified[field];
+                }
+            }
+        }
+
+        me.dirty = false;
+        me.editing = false;
+        me.modified = {};
+
+        if (silent !== true) {
+            me.afterReject();
+        }
+    },
+
+    
+    commit : function(silent) {
+        var me = this;
+
+        me.phantom = me.dirty = me.editing = false;
+        me.modified = {};
+
+        if (silent !== true) {
+            me.afterCommit();
+        }
+    },
+
+    
+    copy : function(newId) {
+        var me = this;
+
+        
+        
+        return new me.self(me.raw, newId, null, Ext.apply({}, me[me.persistenceProperty]));
+    },
+
+    
+    setProxy: function(proxy) {
+        
+        if (!proxy.isProxy) {
+            if (typeof proxy === "string") {
+                proxy = {
+                    type: proxy
+                };
+            }
+            proxy = Ext.createByAlias("proxy." + proxy.type, proxy);
+        }
+        proxy.setModel(this.self);
+        this.proxy = proxy;
+
+        return proxy;
+    },
+
+    
+    getProxy: function() {
+        return this.proxy;
+    },
+
+    
+    validate: function() {
+        var errors      = new Ext.data.Errors(),
+            validations = this.validations,
+            validators  = Ext.data.validations,
+            length, validation, field, valid, type, i;
+
+        if (validations) {
+            length = validations.length;
+
+            for (i = 0; i < length; i++) {
+                validation = validations[i];
+                field = validation.field || validation.name;
+                type  = validation.type;
+                valid = validators[type](validation, this.get(field));
+
+                if (!valid) {
+                    errors.add({
+                        field  : field,
+                        message: validation.message || validators[type + 'Message']
+                    });
+                }
+            }
+        }
+
+        return errors;
+    },
+
+    
+    isValid: function(){
+        return this.validate().isValid();
+    },
+
+    
+    save: function(options) {
+        options = Ext.apply({}, options);
+
+        var me     = this,
+            action = me.phantom ? 'create' : 'update',
+            scope  = options.scope || me,
+            stores = me.stores,
+            i = 0,
+            storeCount,
+            store,
+            args,
+            operation,
+            callback;
+
+        Ext.apply(options, {
+            records: [me],
+            action : action
+        });
+
+        operation = new Ext.data.Operation(options);
+
+        callback = function(operation) {
+            args = [me, operation];
+            if (operation.wasSuccessful()) {
+                for(storeCount = stores.length; i < storeCount; i++) {
+                    store = stores[i];
+                    store.fireEvent('write', store, operation);
+                    store.fireEvent('datachanged', store);
+                    
+                }
+                Ext.callback(options.success, scope, args);
+            } else {
+                Ext.callback(options.failure, scope, args);
+            }
+
+            Ext.callback(options.callback, scope, args);
+        };
+
+        me.getProxy()[action](operation, callback, me);
+
+        return me;
+    },
+
+    
+    destroy: function(options){
+        options = Ext.apply({}, options);
+
+        var me     = this,
+            scope  = options.scope || me,
+            stores = me.stores,
+            i = 0,
+            storeCount,
+            store,
+            args,
+            operation,
+            callback;
+
+        Ext.apply(options, {
+            records: [me],
+            action : 'destroy'
+        });
+
+        operation = new Ext.data.Operation(options);
+        callback = function(operation) {
+            args = [me, operation];
+            if (operation.wasSuccessful()) {
+                for(storeCount = stores.length; i < storeCount; i++) {
+                    store = stores[i];
+                    store.fireEvent('write', store, operation);
+                    store.fireEvent('datachanged', store);
+                    
+                }
+                me.clearListeners();
+                Ext.callback(options.success, scope, args);
+            } else {
+                Ext.callback(options.failure, scope, args);
+            }
+            Ext.callback(options.callback, scope, args);
+        };
+
+        me.getProxy().destroy(operation, callback, me);
+        return me;
+    },
+
+    
+    getId: function() {
+        return this.get(this.idProperty);
+    },
+
+    
+    getObservableId: function() {
+        return this.id;
+    },
+
+    
+    setId: function(id) {
+        this.set(this.idProperty, id);
+        this.phantom  = !(id || id === 0);
+    },
+
+    
+    join : function(store) {
+        Ext.Array.include(this.stores, store);
+
+        
+        this.store = this.stores[0]; 
+    },
+
+    
+    unjoin: function(store) {
+        Ext.Array.remove(this.stores, store);
+        this.store = this.stores[0] || null; 
+    },
+
+    
+    afterEdit : function(modifiedFieldNames) {
+        this.callStore('afterEdit', modifiedFieldNames);
+    },
+
+    
+    afterReject : function() {
+        this.callStore("afterReject");
+    },
+
+    
+    afterCommit: function() {
+        this.callStore('afterCommit');
+    },
+
+    
+    callStore: function(fn) {
+        var args = Ext.Array.clone(arguments),
+            stores = this.stores,
+            i = 0,
+            len = stores.length,
+            store, treeStore;
+
+        args[0] = this;
+        for (; i < len; ++i) {
+            store = stores[i];
+            if (store && typeof store[fn] == "function") {
+                store[fn].apply(store, args);
+            }
+            
+            treeStore = store.treeStore;
+            if (treeStore && typeof treeStore[fn] == "function") {
+                treeStore[fn].apply(treeStore, args);
+            }
+        }
+    },
+
+    
+    getData: function(includeAssociated){
+        var me     = this,
+            fields = me.fields.items,
+            fLen   = fields.length,
+            data   = {},
+            name, f;
+
+        for (f = 0; f < fLen; f++) {
+            name = fields[f].name;
+            data[name] = me.get(name);
+        }
+
+        if (includeAssociated === true) {
+            Ext.apply(data, me.getAssociatedData());
+        }
+        return data;
+    },
+
+    
+    getAssociatedData: function(){
+        return this.prepareAssociatedData({}, 1);
+    },
+
+    
+    prepareAssociatedData: function(seenKeys, depth) {
+        
+        var me               = this,
+            associations     = me.associations.items,
+            associationCount = associations.length,
+            associationData  = {},
+            
+            
+            
+            toRead           = [],
+            toReadKey        = [],
+            toReadIndex      = [],
+            associatedStore, associatedRecords, associatedRecord, o, index, result, seenDepth,
+            associationId, associatedRecordCount, association, i, j, type, name;
+
+        for (i = 0; i < associationCount; i++) {
+            association = associations[i];
+            associationId = association.associationId;
+            
+            seenDepth = seenKeys[associationId];
+            if (seenDepth && seenDepth !== depth) {
+                continue;
+            }
+            seenKeys[associationId] = depth;
+
+            type = association.type;
+            name = association.name;
+            if (type == 'hasMany') {
+                
+                associatedStore = me[association.storeName];
+
+                
+                associationData[name] = [];
+
+                
+                if (associatedStore && associatedStore.getCount() > 0) {
+                    associatedRecords = associatedStore.data.items;
+                    associatedRecordCount = associatedRecords.length;
+
+                    
+                    
+                    for (j = 0; j < associatedRecordCount; j++) {
+                        associatedRecord = associatedRecords[j];
+                        associationData[name][j] = associatedRecord.getData();
+                        toRead.push(associatedRecord);
+                        toReadKey.push(name);
+                        toReadIndex.push(j);
+                    }
+                }
+            } else if (type == 'belongsTo' || type == 'hasOne') {
+                associatedRecord = me[association.instanceName];
+                
+                if (associatedRecord !== undefined) {
+                    associationData[name] = associatedRecord.getData();
+                    toRead.push(associatedRecord);
+                    toReadKey.push(name);
+                    toReadIndex.push(-1);
+                }
+            }
+        }
+        
+        for (i = 0, associatedRecordCount = toRead.length; i < associatedRecordCount; ++i) {
+            associatedRecord = toRead[i];
+            o = associationData[toReadKey[i]];
+            index = toReadIndex[i];
+            result = associatedRecord.prepareAssociatedData(seenKeys, depth + 1);
+            if (index === -1) {
+                Ext.apply(o, result);
+            } else {
+                Ext.apply(o[index], result);
+            }
+        }
+
+        return associationData;
+    }
+});
+
+
+Ext.define('Ext.data.StoreManager', {
+    extend: 'Ext.util.MixedCollection',
+    alternateClassName: ['Ext.StoreMgr', 'Ext.data.StoreMgr', 'Ext.StoreManager'],
+    singleton: true,
+    uses: ['Ext.data.ArrayStore'],
+    
+    
+
+    
+    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(store) {
+        
+        if (Ext.isArray(store)) {
+            var fields = ['field1'], 
+                expand = !Ext.isArray(store[0]),
+                data = store,
+                i,
+                len;
+                
+            if(expand){
+                data = [];
+                for (i = 0, len = store.length; i < len; ++i) {
+                    data.push([store[i]]);
+                }
+            } else {
+                for(i = 2, len = store[0].length; i <= len; ++i){
+                    fields.push('field' + i);
+                }
+            }
+            return new Ext.data.ArrayStore({
+                data  : data,
+                fields: fields,
+                autoDestroy: true,
+                autoCreated: true,
+                expanded: expand
+            });
+        }
+        
+        if (Ext.isString(store)) {
+            
+            return this.get(store);
+        } else {
+            
+            return Ext.data.AbstractStore.create(store);
+        }
+    },
+
+    
+    getKey : function(o) {
+         return o.storeId;
+    }
+}, function() {    
+    
+    Ext.regStore = function(name, config) {
+        var store;
+
+        if (Ext.isObject(name)) {
+            config = name;
+        } else {
+            config.storeId = name;
+        }
+
+        if (config instanceof Ext.data.Store) {
+            store = config;
+        } else {
+            store = new Ext.data.Store(config);
+        }
+
+        return Ext.data.StoreManager.register(store);
+    };
+
+    
+    Ext.getStore = function(name) {
+        return Ext.data.StoreManager.lookup(name);
+    };
+});
+
+
+Ext.define('Ext.layout.component.Dock', {
+
+    
+
+    extend: 'Ext.layout.component.Component',
+
+    alias: 'layout.dock',
+
+    alternateClassName: 'Ext.layout.component.AbstractDock',
+
+    
+
+    type: 'dock',
+
+    initializedBorders: -1,
+
+    horizontalCollapsePolicy: { width: true, x: true },
+
+    verticalCollapsePolicy: { height: true, y: true },
+
+    finishRender: function () {
+        var me = this,
+            target, items;
+
+        me.callParent();
+
+        target = me.getRenderTarget();
+        items = me.getDockedItems();
+
+        me.finishRenderItems(target, items);
+    },
+
+    isItemBoxParent: function (itemContext) {
+        return true;
+    },
+
+    isItemShrinkWrap: function (item) {
+        return true;
+    },
+
+    dockOpposites: {
+        top: 'bottom',
+        right: 'left',
+        bottom: 'top',
+        left: 'right'
+    },
+
+    handleItemBorders: function() {
+        var me = this,
+            owner = me.owner,
+            borders, docked,
+            oldBorders = me.borders,
+            opposites = me.dockOpposites,
+            currentGeneration = owner.dockedItems.generation,
+            i, ln, item, dock, side, borderItem,
+            collapsed = me.collapsed;
+
+        if (me.initializedBorders == currentGeneration || (owner.border && !owner.manageBodyBorders)) {
+            return;
+        }
+
+        me.initializedBorders = currentGeneration;
+
+        
+        me.collapsed = false;
+        docked = me.getLayoutItems();
+        me.collapsed = collapsed;
+
+        borders = { top: [], right: [], bottom: [], left: [] };
+
+        for (i = 0, ln = docked.length; i < ln; i++) {
+            item = docked[i];
+            dock = item.dock;
+
+            if (item.ignoreBorderManagement) {
+                continue;
+            }
+
+            if (!borders[dock].satisfied) {
+                borders[dock].push(item);
+                borders[dock].satisfied = true;
+            }
+
+            if (!borders.top.satisfied && opposites[dock] !== 'top') {
+                borders.top.push(item);
+            }
+            if (!borders.right.satisfied && opposites[dock] !== 'right') {
+                borders.right.push(item);
+            }
+            if (!borders.bottom.satisfied && opposites[dock] !== 'bottom') {
+                borders.bottom.push(item);
+            }
+            if (!borders.left.satisfied && opposites[dock] !== 'left') {
+                borders.left.push(item);
+            }
+        }
+
+        if (oldBorders) {
+            for (side in oldBorders) {
+                if (oldBorders.hasOwnProperty(side)) {
+                    ln = oldBorders[side].length;
+                    if (!owner.manageBodyBorders) {
+                        for (i = 0; i < ln; i++) {
+                            borderItem = oldBorders[side][i];
+                            if (!borderItem.isDestroyed) {
+                                borderItem.removeCls(Ext.baseCSSPrefix + 'docked-noborder-' + side);
+                            }
+                        }
+                        if (!oldBorders[side].satisfied && !owner.bodyBorder) {
+                            owner.removeBodyCls(Ext.baseCSSPrefix + 'docked-noborder-' + side);
+                        }
+                    }
+                    else if (oldBorders[side].satisfied) {
+                        owner.setBodyStyle('border-' + side + '-width', '');
+                    }
+                }
+            }
+        }
+
+        for (side in borders) {
+            if (borders.hasOwnProperty(side)) {
+                ln = borders[side].length;
+                if (!owner.manageBodyBorders) {
+                    for (i = 0; i < ln; i++) {
+                        borders[side][i].addCls(Ext.baseCSSPrefix + 'docked-noborder-' + side);
+                    }
+                    if ((!borders[side].satisfied && !owner.bodyBorder) || owner.bodyBorder === false) {
+                        owner.addBodyCls(Ext.baseCSSPrefix + 'docked-noborder-' + side);
+                    }
+                }
+                else if (borders[side].satisfied) {
+                    owner.setBodyStyle('border-' + side + '-width', '1px');
+                }
+            }
+        }
+
+        me.borders = borders;
+    },
+
+    beforeLayoutCycle: function (ownerContext) {
+        var me = this,
+            owner = me.owner,
+            shrinkWrap = me.sizeModels.shrinkWrap,
+            collapsedHorz, collapsedVert;
+
+        if (owner.collapsed) {
+            if (owner.collapsedVertical()) {
+                collapsedVert = true;
+                ownerContext.measureDimensions = 1;
+            } else {
+                collapsedHorz = true;
+                ownerContext.measureDimensions = 2;
+            }
+        }
+
+        ownerContext.collapsedVert = collapsedVert;
+        ownerContext.collapsedHorz = collapsedHorz;
+
+        
+        
+        
+        
+        if (collapsedVert) {
+            ownerContext.heightModel = shrinkWrap;
+        } else if (collapsedHorz) {
+            ownerContext.widthModel = shrinkWrap;
+        }
+    },
+
+    beginLayout: function(ownerContext) {
+        var me = this,
+            owner = me.owner,
+            docked = me.getLayoutItems(),
+            layoutContext = ownerContext.context,
+            dockedItemCount = docked.length,
+            dockedItems, i, item, itemContext, offsets,
+            collapsed;
+
+        me.callParent(arguments);
+
+        me.handleItemBorders();
+
+        
+        
+        collapsed = owner.getCollapsed();
+        if (collapsed !== me.lastCollapsedState && Ext.isDefined(me.lastCollapsedState)) {
+            
+            if (me.owner.collapsed) {
+                ownerContext.isCollapsingOrExpanding = 1;
+                
+                owner.addClsWithUI(owner.collapsedCls);
+            } else {
+                ownerContext.isCollapsingOrExpanding = 2;
+                
+                owner.removeClsWithUI(owner.collapsedCls);
+                ownerContext.lastCollapsedState = me.lastCollapsedState;
+            }
+        }
+        me.lastCollapsedState = collapsed;
+
+        ownerContext.dockedItems = dockedItems = [];
+
+        for (i = 0; i < dockedItemCount; i++) {
+            item = docked[i];
+            if (item.rendered) {
+                itemContext = layoutContext.getCmp(item);
+                itemContext.dockedAt = { x: 0, y: 0 };
+                itemContext.offsets = offsets = Ext.Element.parseBox(item.offsets || {});
+                offsets.width = offsets.left + offsets.right;
+                offsets.height = offsets.top + offsets.bottom;
+                dockedItems.push(itemContext);
+            }
+        }
+
+        ownerContext.bodyContext = ownerContext.getEl('body');
+    },
+
+    beginLayoutCycle: function(ownerContext) {
+        var me = this,
+            docked = ownerContext.dockedItems,
+            len = docked.length,
+            owner = me.owner,
+            frameBody = owner.frameBody,
+            lastHeightModel = me.lastHeightModel,
+            i, item, dock;
+
+        me.callParent(arguments);
+
+        if (lastHeightModel && lastHeightModel.shrinkWrap &&
+                    !ownerContext.heightModel.shrinkWrap && !me.owner.manageHeight) {
+            owner.body.dom.style.marginBottom = '';
+        }
+
+        if (ownerContext.widthModel.auto) {
+            if (ownerContext.widthModel.shrinkWrap) {
+                owner.el.setWidth(null);
+            }
+            owner.body.setWidth(null);
+            if (frameBody) {
+                frameBody.setWidth(null);
+            }
+        }
+        if (ownerContext.heightModel.auto) {
+            owner.body.setHeight(null);
+            
+            if (frameBody) {
+                frameBody.setHeight(null);
+            }
+        }
+
+        
+        
+        if (ownerContext.collapsedVert) {
+            ownerContext.setContentHeight(0);
+        } else if (ownerContext.collapsedHorz) {
+            ownerContext.setContentWidth(0);
+        }
+
+        
+        
+        for (i = 0; i < len; i++) {
+            item = docked[i].target;
+            dock = item.dock;
+
+            if (dock == 'right') {
+                item.el.setLeft(0);
+            } else if (dock != 'left') {
+                continue;
+            }
+
+            
+        }
+    },
+
+    calculate: function (ownerContext) {
+        var me = this,
+            measure = me.measureAutoDimensions(ownerContext, ownerContext.measureDimensions),
+            state = ownerContext.state,
+            horzDone = state.horzDone,
+            vertDone = state.vertDone,
+            bodyContext = ownerContext.bodyContext,
+            horz, vert, forward, backward;
+
+        
+        ownerContext.borderInfo  || ownerContext.getBorderInfo();
+        ownerContext.paddingInfo || ownerContext.getPaddingInfo();
+        ownerContext.framingInfo || ownerContext.getFraming();
+        bodyContext.borderInfo   || bodyContext.getBorderInfo();
+        bodyContext.paddingInfo  || bodyContext.getPaddingInfo();
+
+        
+        
+        horz = !horzDone &&
+               me.createAxis(ownerContext, measure.contentWidth, ownerContext.widthModel,
+                             'left', 'right', 'x', 'width', 'Width', ownerContext.collapsedHorz);
+        vert = !vertDone &&
+               me.createAxis(ownerContext, measure.contentHeight, ownerContext.heightModel,
+                             'top', 'bottom', 'y', 'height', 'Height', ownerContext.collapsedVert);
+
+        
+        
+        
+        
+        
+        
+        
+        
+        for (forward = 0, backward = ownerContext.dockedItems.length; backward--; ++forward) {
+            if (horz) {
+                me.dockChild(ownerContext, horz, backward, forward);
+            }
+            if (vert) {
+                me.dockChild(ownerContext, vert, backward, forward);
+            }
+        }
+
+        if (horz && me.finishAxis(ownerContext, horz)) {
+            state.horzDone = horzDone = horz;
+        }
+
+        if (vert && me.finishAxis(ownerContext, vert)) {
+            state.vertDone = vertDone = vert;
+        }
+
+        
+        
+        if (horzDone && vertDone && me.finishConstraints(ownerContext, horzDone, vertDone)) {
+            
+            
+            
+            me.finishPositions(ownerContext, horzDone, vertDone);
+        } else {
+            me.done = false;
+        }
+    },
+
+    
+    createAxis: function (ownerContext, contentSize, sizeModel, dockBegin, dockEnd, posProp,
+                          sizeProp, sizePropCap, collapsedAxis) {
+        var begin = 0,
+            owner = this.owner,
+            maxSize = owner['max' + sizePropCap],
+            minSize = owner['min' + sizePropCap] || 0,
+            hasMaxSize = maxSize != null, 
+            setSize = 'set' + sizePropCap,
+            border, bodyContext, frameSize, padding, end;
+
+        if (sizeModel.shrinkWrap) {
+            
+            
+            if (collapsedAxis) {
+                end = 0;
+            } else {
+                bodyContext = ownerContext.bodyContext;
+                end = contentSize + bodyContext.borderInfo[sizeProp];
+            }
+        } else {
+            border    = ownerContext.borderInfo;
+            frameSize = ownerContext.framingInfo;
+            padding   = ownerContext.paddingInfo;
+
+            end = ownerContext.getProp(sizeProp);
+            end -= border[dockEnd] + padding[dockEnd] + frameSize[dockEnd];
+
+            begin = border[dockBegin] + padding[dockBegin] + frameSize[dockBegin];
+        }
+
+        return {
+            shrinkWrap: sizeModel.shrinkWrap,
+            sizeModel: sizeModel,
+            
+            begin: begin,
+            end: end,
+            collapsed: collapsedAxis,
+            horizontal: posProp == 'x',
+            ignoreFrameBegin: false,
+            ignoreFrameEnd: false,
+            initialSize: end - begin,
+            hasMinMaxConstraints: (minSize || hasMaxSize) && sizeModel.shrinkWrap,
+            minSize: minSize,
+            maxSize: hasMaxSize ? maxSize : 1e9,
+            bodyPosProp: this.owner.manageHeight ? posProp : ('margin-' + dockBegin), 
+            dockBegin: dockBegin,    
+            dockEnd: dockEnd,        
+            posProp: posProp,        
+            sizeProp: sizeProp,      
+            sizePropCap: sizePropCap, 
+            setSize: setSize,
+            dockedPixelsEnd: 0
+        };
+    },
+
+    
+    dockChild: function (ownerContext, axis, backward, forward) {
+        var me = this,
+            itemContext = ownerContext.dockedItems[axis.shrinkWrap ? backward : forward],
+            item = itemContext.target,
+            dock = item.dock, 
+            pos;
+
+        if(item.ignoreParentFrame && ownerContext.isCollapsingOrExpanding) {
+            
+            
+            itemContext.clearMarginCache();
+        }
+
+        if (dock == axis.dockBegin) {
+            if (axis.shrinkWrap) {
+                pos = me.dockOutwardBegin(ownerContext, itemContext, item, axis);
+            } else {
+                pos = me.dockInwardBegin(ownerContext, itemContext, item, axis);
+            }
+        } else if (dock == axis.dockEnd) {
+            if (axis.shrinkWrap) {
+                pos = me.dockOutwardEnd(ownerContext, itemContext, item, axis);
+            } else {
+                pos = me.dockInwardEnd(ownerContext, itemContext, item, axis);
+            }
+        } else {
+            pos = me.dockStretch(ownerContext, itemContext, item, axis);
+        }
+
+        itemContext.dockedAt[axis.posProp] = pos;
+    },
+
+    
+    dockInwardBegin: function (ownerContext, itemContext, item, axis) {
+        var pos = axis.begin,
+            sizeProp = axis.sizeProp,
+            size, 
+            dock;
+
+        if (item.ignoreParentFrame) {
+            dock = item.dock;
+            pos -= ownerContext.borderInfo[dock] + ownerContext.paddingInfo[dock] +
+                   ownerContext.framingInfo[dock];
+        }
+
+        if (!item.overlay) {
+            size = itemContext.getProp(sizeProp) + itemContext.getMarginInfo()[sizeProp];
+            axis.begin += size;
+        }
+
+        return pos;
+    },
+
+    
+    dockInwardEnd: function (ownerContext, itemContext, item, axis) {
+        var sizeProp = axis.sizeProp,
+            size = itemContext.getProp(sizeProp) + itemContext.getMarginInfo()[sizeProp],
+            pos = axis.end - size;
+
+        if (!item.overlay) {
+            axis.end = pos;
+        }
+
+        if (item.ignoreParentFrame) {
+            pos += ownerContext.borderInfo[item.dock] + ownerContext.paddingInfo[item.dock] +
+                   ownerContext.framingInfo[item.dock];
+        }
+
+        return pos;
+    },
+
+    
+    dockOutwardBegin: function (ownerContext, itemContext, item, axis) {
+        var pos = axis.begin,
+            sizeProp = axis.sizeProp,
+            dock, size;
+
+        if (axis.collapsed) {
+            axis.ignoreFrameBegin = axis.ignoreFrameEnd = true;
+        } else if (item.ignoreParentFrame) {
+            dock = item.dock;
+            pos -= ownerContext.borderInfo[dock] + ownerContext.paddingInfo[dock] +
+                   ownerContext.framingInfo[dock];
+
+            axis.ignoreFrameBegin = true;
+        }
+
+        if (!item.overlay) {
+            size = itemContext.getProp(sizeProp) + itemContext.getMarginInfo()[sizeProp];
+            pos -= size;
+            axis.begin = pos;
+        }
+
+        return pos;
+    },
+
+    
+    dockOutwardEnd: function (ownerContext, itemContext, item, axis) {
+        var pos = axis.end,
+            sizeProp = axis.sizeProp,
+            dock, size;
+
+        size = itemContext.getProp(sizeProp) + itemContext.getMarginInfo()[sizeProp];
+
+        if (axis.collapsed) {
+            axis.ignoreFrameBegin = axis.ignoreFrameEnd = true;
+        } else if (item.ignoreParentFrame) {
+            dock = item.dock;
+            pos += ownerContext.borderInfo[dock] + ownerContext.paddingInfo[dock] +
+                   ownerContext.framingInfo[dock];
+
+            axis.ignoreFrameEnd = true;
+        }
+
+        if (!item.overlay) {
+            axis.end = pos + size;
+            axis.dockedPixelsEnd += size;
+        }
+
+        return pos;
+    },
+
+    
+    dockStretch: function (ownerContext, itemContext, item, axis) {
+        var dock = item.dock, 
+            sizeProp = axis.sizeProp, 
+            horizontal = dock == 'top' || dock == 'bottom',
+            offsets = itemContext.offsets,
+            border = ownerContext.borderInfo,
+            padding = ownerContext.paddingInfo,
+            endProp = horizontal ? 'right' : 'bottom',
+            startProp = horizontal ? 'left' : 'top',
+            pos = axis.begin + offsets[startProp],
+            margin, size, framing;
+
+        if (item.stretch !== false) {
+            size = axis.end - pos - offsets[endProp];
+
+            if (item.ignoreParentFrame) {
+                framing = ownerContext.framingInfo;
+                pos -= border[startProp] + padding[startProp] + framing[startProp];
+                size += border[sizeProp] + padding[sizeProp] + framing[sizeProp];
+            }
+
+            margin = itemContext.getMarginInfo();
+            size -= margin[sizeProp];
+
+            itemContext[axis.setSize](size);
+        }
+
+        return pos;
+    },
+
+    
+    finishAxis: function (ownerContext, axis) {
+        var size = axis.end - axis.begin,
+            setSizeMethod = axis.setSize,
+            beginName = axis.dockBegin, 
+            endName = axis.dockEnd, 
+            border = ownerContext.borderInfo,
+            padding = ownerContext.paddingInfo,
+            framing = ownerContext.framingInfo,
+            frameSize = padding[beginName] + border[beginName] + framing[beginName],
+            bodyContext = ownerContext.bodyContext,
+            bodyPos, bodySize, dirty;
+
+        if (axis.shrinkWrap) {
+            
+            
+            
+            axis.delta = -axis.begin;  
+
+            bodySize = axis.initialSize;
+
+            if (axis.ignoreFrameBegin) {
+                axis.delta -= border[beginName];
+                bodyPos = -axis.begin - frameSize;
+            } else {
+                size += frameSize;
+                axis.delta += padding[beginName] + framing[beginName];
+                bodyPos = -axis.begin;
+            }
+
+            if (!axis.ignoreFrameEnd) {
+                size += padding[endName] + border[endName] + framing[endName];
+            }
+
+            axis.size = size; 
+
+            if (!axis.horizontal && !this.owner.manageHeight) {
+                
+                
+                dirty = false;
+            }
+        } else {
+            
+            
+            axis.delta = -border[axis.dockBegin]; 
+
+            
+            bodySize = size;
+            bodyPos = axis.begin - frameSize;
+        }
+
+        bodyContext[setSizeMethod](bodySize, dirty);
+        bodyContext.setProp(axis.bodyPosProp, bodyPos);
+
+        return !isNaN(size);
+    },
+
+    
+    finishConstraints: function (ownerContext, horz, vert) {
+        var sizeModels = this.sizeModels,
+            publishWidth = horz.shrinkWrap,
+            publishHeight = vert.shrinkWrap,
+            dirty, height, width, heightModel, widthModel, size;
+
+        if (publishWidth) {
+            size = horz.size;
+
+            if (size < horz.minSize) {
+                widthModel = sizeModels.constrainedMin;
+                width = horz.minSize;
+            } else if (size > horz.maxSize) {
+                widthModel = sizeModels.constrainedMax;
+                width = horz.maxSize;
+            } else {
+                width = size;
+            }
+        }
+
+        if (publishHeight) {
+            size = vert.size;
+
+            if (size < vert.minSize) {
+                heightModel = sizeModels.constrainedMin;
+                height = vert.minSize;
+            } else if (size > vert.maxSize) {
+                heightModel = sizeModels.constrainedMax;
+                height = vert.maxSize;
+            } else {
+                if (!ownerContext.collapsedVert && !this.owner.manageHeight) {
+                    
+                    
+                    dirty = false;
+
+                    
+                    ownerContext.bodyContext.setProp('margin-bottom', vert.dockedPixelsEnd);
+                }
+
+                height = size;
+            }
+        }
+
+        
+
+        if (widthModel || heightModel) {
+            
+            
+            if (widthModel && heightModel &&
+                        widthModel.constrainedMax &&  heightModel.constrainedMin) {
+                ownerContext.invalidate({ widthModel: widthModel });
+                return false;
+            }
+
+            
+            
+            
+            if (!ownerContext.widthModel.calculatedFromShrinkWrap &&
+                        !ownerContext.heightModel.calculatedFromShrinkWrap) {
+                
+                ownerContext.invalidate({ widthModel: widthModel, heightModel: heightModel });
+                return false;
+            }
+
+            
+            
+            
+        }
+
+        
+
+        if (publishWidth) {
+            ownerContext.setWidth(width);
+            if (widthModel) {
+                ownerContext.widthModel = widthModel; 
+            }
+        }
+        if (publishHeight) {
+            ownerContext.setHeight(height, dirty);
+            if (heightModel) {
+                ownerContext.heightModel = heightModel; 
+            }
+        }
+
+        return true;
+    },
+
+    
+    finishPositions: function (ownerContext, horz, vert) {
+        var dockedItems = ownerContext.dockedItems,
+            length = dockedItems.length,
+            deltaX = horz.delta,
+            deltaY = vert.delta,
+            index, itemContext;
+
+        for (index = 0; index < length; ++index) {
+            itemContext = dockedItems[index];
+
+            itemContext.setProp('x', deltaX + itemContext.dockedAt.x);
+            itemContext.setProp('y', deltaY + itemContext.dockedAt.y);
+        }
+    },
+
+    finishedLayout: function(ownerContext) {
+        var me = this,
+            target = ownerContext.target;
+
+        me.callParent(arguments);
+
+        if (!ownerContext.animatePolicy) {
+            if (ownerContext.isCollapsingOrExpanding === 1) {
+                target.afterCollapse(false);
+            } else if (ownerContext.isCollapsingOrExpanding === 2) {
+                target.afterExpand(false);
+            }
+        }
+    },
+
+    getAnimatePolicy: function(ownerContext) {
+        var me = this,
+            lastCollapsedState, policy;
+
+        if (ownerContext.isCollapsingOrExpanding == 1) {
+            lastCollapsedState = me.lastCollapsedState;
+        } else if (ownerContext.isCollapsingOrExpanding == 2) {
+            lastCollapsedState = ownerContext.lastCollapsedState;
+        }
+
+        if (lastCollapsedState == 'left' || lastCollapsedState == 'right') {
+            policy = me.horizontalCollapsePolicy;
+        } else if (lastCollapsedState == 'top' || lastCollapsedState == 'bottom') {
+            policy = me.verticalCollapsePolicy;
+        }
+
+        return policy;
+    },
+
+    
+    getDockedItems: function(order, beforeBody) {
+        var me = this,
+            renderedOnly = (order === 'visual'),
+            all = renderedOnly ? Ext.ComponentQuery.query('[rendered]', me.owner.dockedItems.items) : me.owner.dockedItems.items,
+            sort = all && all.length && order !== false,
+            renderOrder,
+            dock, dockedItems, i, isBefore, length;
+
+        if (beforeBody == null) {
+            dockedItems = sort && !renderedOnly ? all.slice() : all;
+        } else {
+            dockedItems = [];
+
+            for (i = 0, length = all.length; i < length; ++i) {
+                dock = all[i].dock;
+                isBefore = (dock == 'top' || dock == 'left');
+                if (beforeBody ? isBefore : !isBefore) {
+                    dockedItems.push(all[i]);
+                }
+            }
+
+            sort = sort && dockedItems.length;
+        }
+
+        if (sort) {
+            renderOrder = (order = order || 'render') == 'render';
+            Ext.Array.sort(dockedItems, function(a, b) {
+                var aw,
+                    bw;
+
+                
+                
+                if (renderOrder && ((aw = me.owner.dockOrder[a.dock]) !== (bw = me.owner.dockOrder[b.dock]))) {
+
+                    
+                    if (!(aw + bw)) {
+                        return aw - bw;
+                    }
+                }
+
+                aw = me.getItemWeight(a, order);
+                bw = me.getItemWeight(b, order);
+                if ((aw !== undefined) && (bw !== undefined)) {
+                    return aw - bw;
+                }
+                return 0;
+            });
+        }
+
+        return dockedItems || [];
+    },
+
+    getItemWeight: function (item, order) {
+        var weight = item.weight || this.owner.defaultDockWeights[item.dock];
+        return weight[order] || weight;
+    },
+
+    
+    getLayoutItems : function() {
+        var me = this,
+            items,
+            itemCount,
+            item,
+            i,
+            result;
+
+        if (me.owner.collapsed) {
+            result = me.owner.getCollapsedDockedItems();
+        } else {
+            items = me.getDockedItems('visual');
+            itemCount = items.length;
+            result = [];
+            for (i = 0; i < itemCount; i++) {
+                item = items[i];
+                if (!item.hidden) {
+                    result.push(item);
+                }
+            }
+        }
+        return result;
+    },
+
+    
+    measureContentWidth: function (ownerContext) {
+        var bodyContext = ownerContext.bodyContext;
+        return bodyContext.el.getWidth() - bodyContext.getBorderInfo().width;
+    },
+
+    measureContentHeight: function (ownerContext) {
+        var bodyContext = ownerContext.bodyContext;
+        return bodyContext.el.getHeight() - bodyContext.getBorderInfo().height;
+    },
+    
+    redoLayout: function(ownerContext) {
+        var me = this,
+            owner = me.owner;
+        
+        
+        if (ownerContext.isCollapsingOrExpanding == 1) {
+            if (owner.reExpander) {
+                owner.reExpander.el.show();
+            }
+            
+            owner.addClsWithUI(owner.collapsedCls);
+            ownerContext.redo(true);
+        } else if (ownerContext.isCollapsingOrExpanding == 2) {
+            
+            owner.removeClsWithUI(owner.collapsedCls);
+            ownerContext.bodyContext.redo();
+        } 
+    },
+
+    
+    
+    renderChildren: function() {
+        var me = this,
+            items = me.getDockedItems(),
+            target = me.getRenderTarget();
+
+        me.renderItems(items, target);
+    },
+
+    
+    renderItems: function(items, target) {
+        var me = this,
+            dockedItemCount = items.length,
+            itemIndex = 0,
+            correctPosition = 0,
+            staticNodeCount = 0,
+            targetNodes = me.getRenderTarget().dom.childNodes,
+            targetChildCount = targetNodes.length,
+            i, j, targetChildNode, item;
+
+        
+        for (i = 0, j = 0; i < targetChildCount; i++) {
+            targetChildNode = targetNodes[i];
+            if (Ext.fly(targetChildNode).hasCls('x-resizable-handle')) {
+                break;
+            }
+            for (j = 0; j < dockedItemCount; j++) {
+                item = items[j];
+                if (item.rendered && item.el.dom === targetChildNode) {
+                    break;
+                }
+            }
+            
+            
+            if (j === dockedItemCount) {
+                staticNodeCount++;
+            }
+        }
+
+        
+        for (; itemIndex < dockedItemCount; itemIndex++, correctPosition++) {
+            item = items[itemIndex];
+
+            
+            
+            
+            
+            
+            
+            
+            if (itemIndex === correctPosition && (item.dock === 'right' || item.dock === 'bottom')) {
+                correctPosition += staticNodeCount;
+            }
+
+            
+            if (item && !item.rendered) {
+                me.renderItem(item, target, correctPosition);
+            }
+            else if (!me.isValidParent(item, target, correctPosition)) {
+                me.moveItem(item, target, correctPosition);
+            }
+        }
+    },
+
+    undoLayout: function(ownerContext) {
+        var me = this,
+            owner = me.owner;
+        
+        
+        if (ownerContext.isCollapsingOrExpanding == 1) {
+
+            
+            if (owner.reExpander) {
+                owner.reExpander.el.hide();
+            }
+            
+            owner.removeClsWithUI(owner.collapsedCls);
+            ownerContext.undo(true);
+        } else if (ownerContext.isCollapsingOrExpanding == 2) {
+            
+            owner.addClsWithUI(owner.collapsedCls);
+            ownerContext.bodyContext.undo();
+        } 
+    },
+
+    sizePolicy: {
+        nostretch: {
+            setsWidth: 0,
+            setsHeight: 0
+        },
+        stretchH: {
+            setsWidth: 1,
+            setsHeight: 0
+        },
+        stretchV: {
+            setsWidth: 0,
+            setsHeight: 1
+        },
+
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+
+        autoStretchH: {
+            readsWidth: 1,
+            setsWidth: 1,
+            setsHeight: 0
+        },
+        autoStretchV: {
+            readsHeight: 1,
+            setsWidth: 0,
+            setsHeight: 1
+        }
+    },
+
+    getItemSizePolicy: function (item) {
+        var policy = this.sizePolicy,
+            dock, vertical;
+
+        if (item.stretch === false) {
+            return policy.nostretch;
+        }
+
+        dock = item.dock;
+        vertical = (dock == 'left' || dock == 'right');
+
+        
+
+        if (vertical) {
+            return policy.stretchV;
+        }
+
+        return policy.stretchH;
+    },
+
+    
+    configureItem : function(item, pos) {
+        this.callParent(arguments);
+
+        item.addCls(Ext.baseCSSPrefix + 'docked');
+        item.addClsWithUI('docked-' + item.dock);
+    },
+
+    afterRemove : function(item) {
+        this.callParent(arguments);
+        if (this.itemCls) {
+            item.el.removeCls(this.itemCls + '-' + item.dock);
+        }
+        var dom = item.el.dom;
+
+        if (!item.destroying && dom) {
+            dom.parentNode.removeChild(dom);
+        }
+        this.childrenChanged = true;
+    }
+});
+
+
+Ext.define('Ext.toolbar.Fill', {
+    extend: 'Ext.Component',
+    alias: 'widget.tbfill',
+    alternateClassName: 'Ext.Toolbar.Fill',
+    
+    isFill : true,
+    flex: 1
+});
+
+
+Ext.define('Ext.layout.container.boxOverflow.None', {
+    alternateClassName: 'Ext.layout.boxOverflow.None',
+    
+    constructor: function(layout, config) {
+        this.layout = layout;
+        Ext.apply(this, config);
+    },
+
+    handleOverflow: Ext.emptyFn,
+
+    clearOverflow: Ext.emptyFn,
+
+    beginLayout: Ext.emptyFn,
+    beginLayoutCycle: Ext.emptyFn,
+    finishedLayout: Ext.emptyFn,
+
+    completeLayout: function (ownerContext) {
+        var me = this,
+            plan = ownerContext.state.boxPlan,
+            overflow;
+
+        if (plan && plan.tooNarrow) {
+            overflow = me.handleOverflow(ownerContext);
+
+            if (overflow) {
+                if (overflow.reservedSpace) {
+                    me.layout.publishInnerCtSize(ownerContext, overflow.reservedSpace);
+                }
+
+                
+                
+                
+                
+                
+                
+                
+                
+                
+                
+            }
+        } else {
+            me.clearOverflow();
+        }
+    },
+
+    onRemove: Ext.emptyFn,
+
+    
+    getItem: function(item) {
+        return this.layout.owner.getComponent(item);
+    },
+    
+    getOwnerType: function(owner){
+        var type;
+        if (owner.isToolbar) {
+            type = 'toolbar';
+        } else if (owner.isTabBar) {
+            type = 'tabbar';
+        } else if (owner.isMenu) {
+            type = 'menu';
+        } else {
+            type = owner.getXType();
+        }
+        
+        return type;
+    },
+
+    getPrefixConfig: Ext.emptyFn,
+    getSuffixConfig: Ext.emptyFn,
+    getOverflowCls: function() {
+        return '';
+    }
+});
+
+
+Ext.define('Ext.toolbar.Item', {
+    extend: 'Ext.Component',
+    alias: 'widget.tbitem',
+    alternateClassName: 'Ext.Toolbar.Item',
+    enable:Ext.emptyFn,
+    disable:Ext.emptyFn,
+    focus:Ext.emptyFn
+    
+});
+
+
+Ext.define('Ext.toolbar.Separator', {
+    extend: 'Ext.toolbar.Item',
+    alias: 'widget.tbseparator',
+    alternateClassName: 'Ext.Toolbar.Separator',
+    baseCls: Ext.baseCSSPrefix + 'toolbar-separator',
+    focusable: false,
+    
+    border: true
+});
+
+
+Ext.define('Ext.layout.component.Button', {
+
+    
+
+    alias: ['layout.button'],
+
+    extend: 'Ext.layout.component.Auto',
+
+    
+
+    type: 'button',
+
+    cellClsRE: /-btn-(tl|br)\b/,
+    htmlRE: /<.*>/,
+
+    constructor: function () {
+        this.callParent(arguments);
+
+        this.hackWidth = Ext.isIE && (!Ext.isStrict || Ext.isIE6 || Ext.isIE7 || Ext.isIE8);
+        this.heightIncludesPadding = Ext.isIE6 && Ext.isStrict;
+    },
+
+    
+
+    beginLayout: function (ownerContext) {
+        this.callParent(arguments);
+
+        this.cacheTargetInfo(ownerContext);
+    },
+
+    beginLayoutCycle: function(ownerContext) {
+        var me = this,
+            empty = '',
+            owner = me.owner,
+            btnEl = owner.btnEl,
+            btnInnerEl = owner.btnInnerEl,
+            text = owner.text,
+            htmlAutoHeight;
+
+        me.callParent(arguments);
+
+        btnInnerEl.setStyle('overflow', empty);
+
+        
+        if (!ownerContext.widthModel.natural) {
+            owner.el.setStyle('width', empty);
+        }
+
+        
+        
+        htmlAutoHeight = ownerContext.heightModel.shrinkWrap && text && me.htmlRE.test(text);
+
+        btnEl.setStyle('width', empty);
+        btnEl.setStyle('height', htmlAutoHeight ? 'auto' : empty);
+        btnInnerEl.setStyle('width', empty);
+        btnInnerEl.setStyle('height', htmlAutoHeight ? 'auto' : empty);
+        btnInnerEl.setStyle('line-height', htmlAutoHeight ? 'normal' : empty);
+        btnInnerEl.setStyle('padding-top', empty);
+        owner.btnIconEl.setStyle('width', empty);
+    },
+
+    calculateOwnerHeightFromContentHeight: function (ownerContext, contentHeight) {
+        return contentHeight;
+    },
+
+    calculateOwnerWidthFromContentWidth: function (ownerContext, contentWidth) {
+        return contentWidth;
+    },
+
+    measureContentWidth: function (ownerContext) {
+        var me = this,
+            owner = me.owner,
+            btnEl = owner.btnEl,
+            btnInnerEl = owner.btnInnerEl,
+            text = owner.text,
+            btnFrameWidth, metrics, sizeIconEl, width, btnElContext, btnInnerElContext;
+
+        
+        
+        
+        
+        if (owner.text && me.hackWidth && btnEl) {
+            btnFrameWidth = me.btnFrameWidth;
+
+            
+            
+            
+            if (text.indexOf('>') === -1) {
+                text = text.replace(/</g, '&lt;');
+            }
+
+            metrics = Ext.util.TextMetrics.measure(btnInnerEl, text);
+
+            width = metrics.width + btnFrameWidth + me.adjWidth;
+
+            btnElContext = ownerContext.getEl('btnEl');
+            btnInnerElContext = ownerContext.getEl('btnInnerEl');
+            sizeIconEl = (owner.icon || owner.iconCls) && 
+                    (owner.iconAlign == "top" || owner.iconAlign == "bottom");
+
+            
+            
+            
+            ownerContext.setWidth(width); 
+
+            btnElContext.setWidth(metrics.width + btnFrameWidth);
+            btnInnerElContext.setWidth(metrics.width + btnFrameWidth);
+
+            if (sizeIconEl) {
+                owner.btnIconEl.setWidth(metrics.width + btnFrameWidth);
+            }
+        } else {
+            width = ownerContext.el.getWidth();
+        }
+
+        return width;
+    },
+
+    measureContentHeight: function (ownerContext) {
+        var me = this,
+            owner = me.owner,
+            btnInnerEl = owner.btnInnerEl,
+            btnItem = ownerContext.getEl('btnEl'),
+            btnInnerItem = ownerContext.getEl('btnInnerEl'),
+            minTextHeight = me.minTextHeight,
+            adjHeight = me.adjHeight,
+            text = owner.getText(),
+            height,
+            textHeight,
+            topPadding;
+
+        if (owner.vertical) {
+            height = Ext.util.TextMetrics.measure(btnInnerEl, owner.text).width;
+            height += me.btnFrameHeight + adjHeight;
+
+            
+            ownerContext.setHeight(height, true, true);
+        }
+        else {
+            
+            if (text && me.htmlRE.test(text)) {
+                textHeight = btnInnerEl.getHeight();
+
+                
+                if (textHeight < minTextHeight) {
+                    topPadding = Math.floor((minTextHeight - textHeight) / 2);
+
+                    
+                    
+                    btnInnerItem.setHeight(minTextHeight - (me.heightIncludesPadding ? topPadding : 0));
+                    btnInnerItem.setProp('padding-top', topPadding);
+
+                    textHeight = minTextHeight;
+                }
+
+                
+                height = textHeight + adjHeight;
+            }
+            else {
+                height = ownerContext.el.getHeight();
+            }
+        }
+
+        
+        btnItem.setHeight(height - adjHeight);
+
+        return height;
+    },
+
+    publishInnerHeight: function(ownerContext, height) {
+        var me = this,
+            owner = me.owner,
+            isNum = Ext.isNumber,
+            btnItem = ownerContext.getEl('btnEl'),
+            btnInnerEl = owner.btnInnerEl,
+            btnInnerItem = ownerContext.getEl('btnInnerEl'),
+            btnHeight = isNum(height) ? height - me.adjHeight : height,
+            btnFrameHeight = me.btnFrameHeight,
+            text = owner.getText(),
+            textHeight,
+            paddingTop;
+
+        btnItem.setHeight(btnHeight);
+        btnInnerItem.setHeight(btnHeight);
+
+        
+        if (!owner.vertical && btnHeight >= 0) {
+            btnInnerItem.setProp('line-height', btnHeight - btnFrameHeight + 'px');
+        }
+
+        
+        
+        
+        
+        
+        if (text && me.htmlRE.test(text)) {
+            btnInnerItem.setProp('line-height', 'normal');
+            btnInnerEl.setStyle('line-height', 'normal');
+            textHeight = Ext.util.TextMetrics.measure(btnInnerEl, text).height;
+            paddingTop = Math.floor(Math.max(btnHeight - btnFrameHeight - textHeight, 0) / 2);
+            btnInnerItem.setProp('padding-top', me.btnFrameTop + paddingTop);
+            btnInnerItem.setHeight(btnHeight - (me.heightIncludesPadding ? paddingTop : 0));
+        }
+    },
+
+    publishInnerWidth: function(ownerContext, width) {
+        var me = this,
+            isNum = Ext.isNumber,
+            btnItem = ownerContext.getEl('btnEl'),
+            btnInnerItem = ownerContext.getEl('btnInnerEl'),
+            btnWidth = isNum(width) ? width - me.adjWidth : width;
+
+        btnItem.setWidth(btnWidth);
+        btnInnerItem.setWidth(btnWidth);
+    },
+    
+    clearTargetCache: function(){
+        delete this.adjWidth;    
+    },
+
+    cacheTargetInfo: function(ownerContext) {
+        var me = this,
+            owner = me.owner,
+            scale = owner.scale,
+            padding, frameSize, btnWrapPadding, btnInnerEl, innerFrameSize;
+
+        
+        if (!('adjWidth' in me) || me.lastScale !== scale) {
+            
+            if (me.lastScale) {
+                owner.btnInnerEl.setStyle('line-height', '');
+            }
+
+            me.lastScale = scale;
+
+            padding = ownerContext.getPaddingInfo();
+            frameSize = ownerContext.getFrameInfo();
+            btnWrapPadding = ownerContext.getEl('btnWrap').getPaddingInfo();
+            btnInnerEl = ownerContext.getEl('btnInnerEl');
+            innerFrameSize = btnInnerEl.getPaddingInfo();
+
+            Ext.apply(me, {
+                
+                adjWidth       : btnWrapPadding.width + frameSize.width + padding.width,
+                adjHeight      : btnWrapPadding.height + frameSize.height + padding.height,
+                btnFrameWidth  : innerFrameSize.width,
+                btnFrameHeight : innerFrameSize.height,
+                btnFrameTop    : innerFrameSize.top,
+
+                
+                minTextHeight  : parseInt(btnInnerEl.getStyle('line-height'), 10)
+            });
+        }
+
+        me.callParent(arguments);
+    },
+    
+    finishedLayout: function(){
+        var owner = this.owner;
+        this.callParent(arguments);
+        
+        
+        if (Ext.isWebKit) {
+            owner.el.dom.offsetWidth;
+        }
+    }
+});
+
+
+Ext.define('Ext.menu.Manager', {
+    singleton: true,
+    requires: [
+        'Ext.util.MixedCollection',
+        'Ext.util.KeyMap'
+    ],
+    alternateClassName: 'Ext.menu.MenuMgr',
+
+    uses: ['Ext.menu.Menu'],
+
+    menus: {},
+    groups: {},
+    attached: false,
+    lastShow: new Date(),
+
+    init: function() {
+        var me = this;
+        
+        me.active = new Ext.util.MixedCollection();
+        Ext.getDoc().addKeyListener(27, function() {
+            if (me.active.length > 0) {
+                me.hideAll();
+            }
+        }, me);
+    },
+
+    
+    hideAll: function() {
+        var active = this.active,
+        clone, menus, m, mLen;
+
+        if (active && active.length > 0) {
+            clone = active.clone();
+            menus = clone.items;
+            mLen  = menus.length;
+
+            for (m = 0; m < mLen; m++) {
+                menus[m].hide();
+            }
+
+            return true;
+        }
+        return false;
+    },
+
+    onHide: function(m) {
+        var me = this,
+            active = me.active;
+        active.remove(m);
+        if (active.length < 1) {
+            Ext.getDoc().un('mousedown', me.onMouseDown, me);
+            me.attached = false;
+        }
+    },
+
+    onShow: function(m) {
+        var me = this,
+            active   = me.active,
+            last     = active.last(),
+            attached = me.attached,
+            menuEl   = m.getEl(),
+            zIndex;
+
+        me.lastShow = new Date();
+        active.add(m);
+        if (!attached) {
+            Ext.getDoc().on('mousedown', me.onMouseDown, me, {
+                
+                
+                buffer: Ext.isIE ? 10 : undefined
+            });
+            me.attached = true;
+        }
+        m.toFront();
+    },
+
+    onBeforeHide: function(m) {
+        if (m.activeChild) {
+            m.activeChild.hide();
+        }
+        if (m.autoHideTimer) {
+            clearTimeout(m.autoHideTimer);
+            delete m.autoHideTimer;
+        }
+    },
+
+    onBeforeShow: function(m) {
+        var active = this.active,
+            parentMenu = m.parentMenu;
+            
+        active.remove(m);
+        if (!parentMenu && !m.allowOtherMenus) {
+            this.hideAll();
+        }
+        else if (parentMenu && parentMenu.activeChild && m != parentMenu.activeChild) {
+            parentMenu.activeChild.hide();
+        }
+    },
+
+    
+    onMouseDown: function(e) {
+        var me = this,
+            active = me.active,
+            lastShow = me.lastShow;
+
+        if (Ext.Date.getElapsed(lastShow) > 50 && active.length > 0 && !e.getTarget('.' + Ext.baseCSSPrefix + 'menu')) {
+            me.hideAll();
+        }
+    },
+
+    
+    register: function(menu) {
+        var me = this;
+
+        if (!me.active) {
+            me.init();
+        }
+
+        if (menu.floating) {
+            me.menus[menu.id] = menu;
+            menu.on({
+                beforehide: me.onBeforeHide,
+                hide: me.onHide,
+                beforeshow: me.onBeforeShow,
+                show: me.onShow,
+                scope: me
+            });
+        }
+    },
+
+    
+    get: function(menu) {
+        var menus = this.menus;
+        
+        if (typeof menu == 'string') { 
+            if (!menus) {  
+                return null;
+            }
+            return menus[menu];
+        } else if (menu.isMenu) {  
+            return menu;
+        } else if (Ext.isArray(menu)) { 
+            return new Ext.menu.Menu({items:menu});
+        } else { 
+            return Ext.ComponentManager.create(menu, 'menu');
+        }
+    },
+
+    
+    unregister: function(menu) {
+        var me = this,
+            menus = me.menus,
+            active = me.active;
+
+        delete menus[menu.id];
+        active.remove(menu);
+        menu.un({
+            beforehide: me.onBeforeHide,
+            hide: me.onHide,
+            beforeshow: me.onBeforeShow,
+            show: me.onShow,
+            scope: me
+        });
+    },
+
+    
+    registerCheckable: function(menuItem) {
+        var groups  = this.groups,
+            groupId = menuItem.group;
+
+        if (groupId) {
+            if (!groups[groupId]) {
+                groups[groupId] = [];
+            }
+
+            groups[groupId].push(menuItem);
+        }
+    },
+
+    
+    unregisterCheckable: function(menuItem) {
+        var groups  = this.groups,
+            groupId = menuItem.group;
+
+        if (groupId) {
+            Ext.Array.remove(groups[groupId], menuItem);
+        }
+    },
+
+    onCheckChange: function(menuItem, state) {
+        var groups  = this.groups,
+            groupId = menuItem.group,
+            i       = 0,
+            group, ln, curr;
+
+        if (groupId && state) {
+            group = groups[groupId];
+            ln = group.length;
+            for (; i < ln; i++) {
+                curr = group[i];
+                if (curr != menuItem) {
+                    curr.setChecked(false);
+                }
+            }
+        }
+    }
+});
+
+
+Ext.define('Ext.util.ClickRepeater', {
+    extend: 'Ext.util.Observable',
+
+    
+    constructor : function(el, config){
+        var me = this;
+
+        me.el = Ext.get(el);
+        me.el.unselectable();
+
+        Ext.apply(me, config);
+
+        me.callParent();
+
+        me.addEvents(
+        
+        "mousedown",
+        
+        "click",
+        
+        "mouseup"
+        );
+
+        if(!me.disabled){
+            me.disabled = true;
+            me.enable();
+        }
+
+        
+        if(me.handler){
+            me.on("click", me.handler,  me.scope || me);
+        }
+    },
+
+    
+
+    
+
+    
+
+    
+    interval : 20,
+
+    
+    delay: 250,
+
+    
+    preventDefault : true,
+
+    
+    stopDefault : false,
+
+    timer : 0,
+
+    
+    enable: function(){
+        if(this.disabled){
+            this.el.on('mousedown', this.handleMouseDown, this);
+            
+            
+            if (Ext.isIE && !(Ext.isStrict && Ext.isIE9)){
+                this.el.on('dblclick', this.handleDblClick, this);
+            }
+            if(this.preventDefault || this.stopDefault){
+                this.el.on('click', this.eventOptions, this);
+            }
+        }
+        this.disabled = false;
+    },
+
+    
+    disable: function( force){
+        if(force || !this.disabled){
+            clearTimeout(this.timer);
+            if(this.pressedCls){
+                this.el.removeCls(this.pressedCls);
+            }
+            Ext.getDoc().un('mouseup', this.handleMouseUp, this);
+            this.el.removeAllListeners();
+        }
+        this.disabled = true;
+    },
+
+    
+    setDisabled: function(disabled){
+        this[disabled ? 'disable' : 'enable']();
+    },
+
+    eventOptions: function(e){
+        if(this.preventDefault){
+            e.preventDefault();
+        }
+        if(this.stopDefault){
+            e.stopEvent();
+        }
+    },
+
+    
+    destroy : function() {
+        this.disable(true);
+        Ext.destroy(this.el);
+        this.clearListeners();
+    },
+
+    handleDblClick : function(e){
+        clearTimeout(this.timer);
+        this.el.blur();
+
+        this.fireEvent("mousedown", this, e);
+        this.fireEvent("click", this, e);
+    },
+
+    
+    handleMouseDown : function(e){
+        clearTimeout(this.timer);
+        this.el.blur();
+        if(this.pressedCls){
+            this.el.addCls(this.pressedCls);
+        }
+        this.mousedownTime = new Date();
+
+        Ext.getDoc().on("mouseup", this.handleMouseUp, this);
+        this.el.on("mouseout", this.handleMouseOut, this);
+
+        this.fireEvent("mousedown", this, e);
+        this.fireEvent("click", this, e);
+
+        
+        if (this.accelerate) {
+            this.delay = 400;
+        }
+
+        
+        
+        e = new Ext.EventObjectImpl(e);
+
+        this.timer =  Ext.defer(this.click, this.delay || this.interval, this, [e]);
+    },
+
+    
+    click : function(e){
+        this.fireEvent("click", this, e);
+        this.timer =  Ext.defer(this.click, this.accelerate ?
+            this.easeOutExpo(Ext.Date.getElapsed(this.mousedownTime),
+                400,
+                -390,
+                12000) :
+            this.interval, this, [e]);
+    },
+
+    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.pressedCls){
+            this.el.removeCls(this.pressedCls);
+        }
+        this.el.on("mouseover", this.handleMouseReturn, this);
+    },
+
+    
+    handleMouseReturn : function(){
+        this.el.un("mouseover", this.handleMouseReturn, this);
+        if(this.pressedCls){
+            this.el.addCls(this.pressedCls);
+        }
+        this.click();
+    },
+
+    
+    handleMouseUp : function(e){
+        clearTimeout(this.timer);
+        this.el.un("mouseover", this.handleMouseReturn, this);
+        this.el.un("mouseout", this.handleMouseOut, this);
+        Ext.getDoc().un("mouseup", this.handleMouseUp, this);
+        if(this.pressedCls){
+            this.el.removeCls(this.pressedCls);
+        }
+        this.fireEvent("mouseup", this, e);
+    }
+});
+
+
+Ext.define('Ext.util.TextMetrics', {
+    statics: {
+        shared: null,
+        
+        measure: function(el, text, fixedWidth){
+            var me = this,
+                shared = me.shared;
+            
+            if(!shared){
+                shared = me.shared = new me(el, fixedWidth);
+            }
+            shared.bind(el);
+            shared.setFixedWidth(fixedWidth || 'auto');
+            return shared.getSize(text);
+        },
+        
+        
+        destroy: function(){
+            var me = this;
+            Ext.destroy(me.shared);
+            me.shared = null;
+        }
+    },
+    
+    
+    constructor: function(bindTo, fixedWidth){
+        var measure = this.measure = Ext.getBody().createChild({
+            cls: Ext.baseCSSPrefix + 'textmetrics'
+        });
+        this.el = Ext.get(bindTo);
+        
+        measure.position('absolute');
+        measure.setLeftTop(-1000, -1000);
+        measure.hide();
+
+        if (fixedWidth) {
+           measure.setWidth(fixedWidth);
+        }
+    },
+    
+    
+    getSize: function(text){
+        var measure = this.measure,
+            size;
+        
+        measure.update(text);
+        size = measure.getSize();
+        measure.update('');
+        return size;
+    },
+    
+    
+    bind: function(el){
+        var me = this;
+        
+        me.el = Ext.get(el);
+        me.measure.setStyle(
+            me.el.getStyles('font-size','font-style', 'font-weight', 'font-family','line-height', 'text-transform', 'letter-spacing')
+        );
+    },
+    
+    
+     setFixedWidth : function(width){
+         this.measure.setWidth(width);
+     },
+     
+     
+     getWidth : function(text){
+         this.measure.dom.style.width = 'auto';
+         return this.getSize(text).width;
+     },
+     
+     
+     getHeight : function(text){
+         return this.getSize(text).height;
+     },
+     
+     
+     destroy: function(){
+         var me = this;
+         me.measure.remove();
+         delete me.el;
+         delete me.measure;
+     }
+}, function(){
+    Ext.Element.addMethods({
+        
+        getTextWidth : function(text, min, max){
+            return Ext.Number.constrain(Ext.util.TextMetrics.measure(this.dom, Ext.value(text, this.dom.innerHTML, true)).width, min || 0, max || 1000000);
+        }
+    });
+});
+
+
+Ext.define('Ext.button.Button', {
+
+    
+    alias: 'widget.button',
+    extend: 'Ext.Component',
+
+    requires: [
+        'Ext.menu.Manager',
+        'Ext.util.ClickRepeater',
+        'Ext.layout.component.Button',
+        'Ext.util.TextMetrics',
+        'Ext.util.KeyMap'
+    ],
+
+    alternateClassName: 'Ext.Button',
+    
+
+    
+    isButton: true,
+    componentLayout: 'button',
+
+    
+    hidden: false,
+
+    
+    disabled: false,
+
+    
+    pressed: false,
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+    enableToggle: false,
+
+    
+
+    
+
+    
+    menuAlign: 'tl-bl?',
+
+    
+    textAlign: 'center',
+
+    
+
+    
+
+    
+    type: 'button',
+
+    
+    clickEvent: 'click',
+
+    
+    preventDefault: true,
+
+    
+    handleMouseEvents: true,
+
+    
+    tooltipType: 'qtip',
+
+    
+    baseCls: Ext.baseCSSPrefix + 'btn',
+
+    
+    pressedCls: 'pressed',
+
+    
+    overCls: 'over',
+
+    
+    focusCls: 'focus',
+
+    
+    menuActiveCls: 'menu-active',
+
+    
+    
+    
+     hrefTarget: '_blank',
+     
+     border: true,
+
+    
+
+    
+
+    childEls: [
+        'btnEl', 'btnWrap', 'btnInnerEl', 'btnIconEl'
+    ],
+
+    renderTpl: [
+        '<em id="{id}-btnWrap"<tpl if="splitCls"> class="{splitCls}"</tpl>>',
+            '<tpl if="href">',
+                '<a id="{id}-btnEl" href="{href}" class="{btnCls}" target="{hrefTarget}"',
+                    '<tpl if="tabIndex"> tabIndex="{tabIndex}"</tpl>',
+                    '<tpl if="disabled"> disabled="disabled"</tpl>',
+                    ' role="link">',
+                    '<span id="{id}-btnInnerEl" class="{baseCls}-inner">',
+                        '{text}',
+                    '</span>',
+                    '<span id="{id}-btnIconEl" class="{baseCls}-icon {iconCls}"<tpl if="iconUrl"> style="background-image:url({iconUrl})"</tpl>></span>',
+                '</a>',
+            '<tpl else>',
+                '<button id="{id}-btnEl" type="{type}" class="{btnCls}" hidefocus="true"',
+                    
+                    
+                    '<tpl if="tabIndex"> tabIndex="{tabIndex}"</tpl>',
+                    '<tpl if="disabled"> disabled="disabled"</tpl>',
+                    ' role="button" autocomplete="off">',
+                    '<span id="{id}-btnInnerEl" class="{baseCls}-inner" style="{innerSpanStyle}">',
+                        '{text}',
+                    '</span>',
+                    '<span id="{id}-btnIconEl" class="{baseCls}-icon {iconCls}"<tpl if="iconUrl"> style="background-image:url({iconUrl})"</tpl>></span>',
+                '</button>',
+            '</tpl>',
+        '</em>',
+        '<tpl if="closable">',
+            '<a id="{id}-closeEl" href="#" class="{baseCls}-close-btn" title="{closeText}"></a>',
+        '</tpl>'
+    ],
+
+    
+    scale: 'small',
+
+    
+    allowedScales: ['small', 'medium', 'large'],
+
+    
+
+    
+    iconAlign: 'left',
+
+    
+    arrowAlign: 'right',
+
+    
+    arrowCls: 'arrow',
+
+    
+
+    
+
+    
+
+    maskOnDisable: false,
+    
+    
+    persistentPadding: undefined,
+
+    shrinkWrap: 3,
+
+    frame: true,
+
+    
+    initComponent: function() {
+        var me = this;
+        me.callParent(arguments);
+
+        me.addEvents(
+            
+            'click',
+
+            
+            'toggle',
+
+            
+            'mouseover',
+
+            
+            'mouseout',
+
+            
+            'menushow',
+
+            
+            'menuhide',
+
+            
+            'menutriggerover',
+
+            
+            'menutriggerout'
+        );
+
+        if (me.menu) {
+            
+            me.split = true;
+
+            
+            me.menu = Ext.menu.Manager.get(me.menu);
+            me.menu.ownerButton = me;
+        }
+
+        
+        if (me.url) {
+            me.href = me.url;
+        }
+
+        
+        if (me.href && !me.hasOwnProperty('preventDefault')) {
+            me.preventDefault = false;
+        }
+
+        if (Ext.isString(me.toggleGroup) && me.toggleGroup !== '') {
+            me.enableToggle = true;
+        }
+        
+        if (me.html && !me.text) {
+            me.text = me.html;
+            delete me.html;
+        }
+
+    },
+
+    
+    getActionEl: function() {
+        return this.btnEl;
+    },
+
+    
+    getFocusEl: function() {
+        return this.useElForFocus ? this.el : this.btnEl;
+    },
+
+    
+    onFocus: function(e) {
+        var me = this;
+
+        
+        
+        me.useElForFocus = true;
+        me.callParent(arguments);
+        me.useElForFocus = false;
+    },
+
+    
+    onBlur : function(e) {
+        this.useElForFocus = true;
+        this.callParent(arguments);
+        this.useElForFocus = false;
+    },
+    
+    
+    onDisable: function(){
+        this.useElForFocus = true;
+        this.callParent(arguments);
+        this.useElForFocus = false;
+    },
+
+    
+    setComponentCls: function() {
+        var me = this,
+            cls = me.getComponentCls();
+
+        if (!Ext.isEmpty(me.oldCls)) {
+            me.removeClsWithUI(me.oldCls);
+            me.removeClsWithUI(me.pressedCls);
+        }
+
+        me.oldCls = cls;
+        me.addClsWithUI(cls);
+    },
+
+    getComponentCls: function() {
+        var me = this,
+            cls = [];
+
+        
+        if (me.iconCls || me.icon) {
+            if (me.text) {
+                cls.push('icon-text-' + me.iconAlign);
+            } else {
+                cls.push('icon');
+            }
+        } else if (me.text) {
+            cls.push('noicon');
+        }
+
+        if (me.pressed) {
+            cls.push(me.pressedCls);
+        }
+        return cls;
+    },
+
+    beforeRender: function () {
+        var me = this;
+
+        me.callParent();
+
+        
+        me.oldCls = me.getComponentCls();
+        me.addClsWithUI(me.oldCls);
+
+        
+        Ext.applyIf(me.renderData, me.getTemplateArgs());
+
+        if (me.scale) {
+            me.setScale(me.scale);
+        }
+    },
+
+    
+    onRender: function() {
+        var me = this,
+            addOnclick,
+            btn,
+            btnListeners;
+
+        me.doc = Ext.getDoc();
+        me.callParent(arguments);
+
+        
+        if (me.split && me.arrowTooltip) {
+            me.arrowEl.dom.setAttribute(me.getTipAttr(), me.arrowTooltip);
+        }
+
+        
+        btn = me.el;
+
+        if (me.tooltip) {
+            me.setTooltip(me.tooltip, true);
+        }
+
+        
+        if (me.handleMouseEvents) {
+            btnListeners = {
+                scope: me,
+                mouseover: me.onMouseOver,
+                mouseout: me.onMouseOut,
+                mousedown: me.onMouseDown
+            };
+            if (me.split) {
+                btnListeners.mousemove = me.onMouseMove;
+            }
+        } else {
+            btnListeners = {
+                scope: me
+            };
+        }
+
+        
+        if (me.menu) {
+            me.mon(me.menu, {
+                scope: me,
+                show: me.onMenuShow,
+                hide: me.onMenuHide
+            });
+
+            me.keyMap = new Ext.util.KeyMap({
+                target: me.el,
+                key: Ext.EventObject.DOWN,
+                handler: me.onDownKey,
+                scope: me
+            });
+        }
+
+        
+        if (me.repeat) {
+            me.mon(new Ext.util.ClickRepeater(btn, Ext.isObject(me.repeat) ? me.repeat: {}), 'click', me.onRepeatClick, me);
+        } else {
+
+            
+            if (btnListeners[me.clickEvent]) {
+                addOnclick = true;
+            } else {
+                btnListeners[me.clickEvent] = me.onClick;
+            }
+        }
+
+        
+        me.mon(btn, btnListeners);
+
+        
+        if (addOnclick) {
+            me.mon(btn, me.clickEvent, me.onClick, me);
+        }
+
+        
+        Ext.ButtonToggleManager.register(me);
+    },
+
+    
+    getTemplateArgs: function() {
+        var me = this,
+            persistentPadding = me.getPersistentPadding(),
+            innerSpanStyle = '';
+
+        
+        if (Math.max.apply(Math, persistentPadding) > 0) {
+            innerSpanStyle = 'margin:' + Ext.Array.map(persistentPadding, function(pad) {
+                return -pad + 'px';
+            }).join(' ');
+        }
+
+        return {
+            href     : me.getHref(),
+            disabled : me.disabled,
+            hrefTarget: me.hrefTarget,
+            type     : me.type,
+            btnCls   : me.getBtnCls(),
+            splitCls : me.getSplitCls(),
+            iconUrl  : me.icon,
+            iconCls  : me.iconCls,
+            text     : me.text || '&#160;',
+            tabIndex : me.tabIndex,
+            innerSpanStyle: innerSpanStyle
+        };
+    },
+
+    
+    getHref: function() {
+        var me = this,
+            params = Ext.apply({}, me.baseParams);
+
+        
+        params = Ext.apply(params, me.params);
+        return me.href ? Ext.urlAppend(me.href, Ext.Object.toQueryString(params)) : false;
+    },
+
+    
+    setParams: function(params) {
+        this.params = params;
+        this.btnEl.dom.href = this.getHref();
+    },
+
+    getSplitCls: function() {
+        var me = this;
+        return me.split ? (me.baseCls + '-' + me.arrowCls) + ' ' + (me.baseCls + '-' + me.arrowCls + '-' + me.arrowAlign) : '';
+    },
+
+    getBtnCls: function() {
+        return this.textAlign ? this.baseCls + '-' + this.textAlign : '';
+    },
+
+    
+    setIconCls: function(cls) {
+        var me = this,
+            btnIconEl = me.btnIconEl,
+            oldCls = me.iconCls;
+            
+        me.iconCls = cls;
+        if (btnIconEl) {
+            
+            btnIconEl.removeCls(oldCls);
+            btnIconEl.addCls(cls || '');
+            me.setComponentCls();
+            if (me.didIconStateChange(oldCls, cls)) {
+                me.updateLayout();
+            }
+        }
+        return me;
+    },
+
+    
+    setTooltip: function(tooltip, initial) {
+        var me = this;
+
+        if (me.rendered) {
+            if (!initial) {
+                me.clearTip();
+            }
+            if (Ext.isObject(tooltip)) {
+                Ext.tip.QuickTipManager.register(Ext.apply({
+                    target: me.btnEl.id
+                },
+                tooltip));
+                me.tooltip = tooltip;
+            } else {
+                me.btnEl.dom.setAttribute(me.getTipAttr(), tooltip);
+            }
+        } else {
+            me.tooltip = tooltip;
+        }
+        return me;
+    },
+
+    
+    setTextAlign: function(align) {
+        var me = this,
+            btnEl = me.btnEl;
+
+        if (btnEl) {
+            btnEl.removeCls(me.baseCls + '-' + me.textAlign);
+            btnEl.addCls(me.baseCls + '-' + align);
+        }
+        me.textAlign = align;
+        return me;
+    },
+
+    getTipAttr: function(){
+        return this.tooltipType == 'qtip' ? 'data-qtip' : 'title';
+    },
+
+    
+    getRefItems: function(deep){
+        var menu = this.menu,
+            items;
+        
+        if (menu) {
+            items = menu.getRefItems(deep);
+            items.unshift(menu);
+        }
+        return items || [];
+    },
+
+    
+    clearTip: function() {
+        if (Ext.isObject(this.tooltip)) {
+            Ext.tip.QuickTipManager.unregister(this.btnEl);
+        }
+    },
+
+    
+    beforeDestroy: function() {
+        var me = this;
+        if (me.rendered) {
+            me.clearTip();
+        }
+        if (me.menu && me.destroyMenu !== false) {
+            Ext.destroy(me.menu);
+        }
+        Ext.destroy(me.btnInnerEl, me.repeater);
+        me.callParent();
+    },
+
+    
+    onDestroy: function() {
+        var me = this;
+        if (me.rendered) {
+            me.doc.un('mouseover', me.monitorMouseOver, me);
+            me.doc.un('mouseup', me.onMouseUp, me);
+            delete me.doc;
+            Ext.ButtonToggleManager.unregister(me);
+
+            Ext.destroy(me.keyMap);
+            delete me.keyMap;
+        }
+        me.callParent();
+    },
+
+    
+    setHandler: function(handler, scope) {
+        this.handler = handler;
+        this.scope = scope;
+        return this;
+    },
+
+    
+    setText: function(text) {
+        var me = this;
+        me.text = text;
+        if (me.rendered) {
+            me.btnInnerEl.update(text || '&#160;');
+            me.setComponentCls();
+            if (Ext.isStrict && Ext.isIE8) {
+                
+                me.el.repaint();
+            }
+            me.updateLayout();
+        }
+        return me;
+    },
+
+    
+    setIcon: function(icon) {
+        var me = this,
+            btnIconEl = me.btnIconEl,
+            oldIcon = me.icon;
+            
+        me.icon = icon;
+        if (btnIconEl) {
+            btnIconEl.setStyle('background-image', icon ? 'url(' + icon + ')': '');
+            me.setComponentCls();
+            if (me.didIconStateChange(oldIcon, icon)) {
+                me.updateLayout();
+            }
+        }
+        return me;
+    },
+    
+    
+    didIconStateChange: function(old, current) {
+        var currentEmpty = Ext.isEmpty(current);
+        return Ext.isEmpty(old) ? !currentEmpty : currentEmpty;
+    },
+
+    
+    getText: function() {
+        return this.text;
+    },
+
+    
+    toggle: function(state, suppressEvent) {
+        var me = this;
+        state = state === undefined ? !me.pressed: !!state;
+        if (state !== me.pressed) {
+            if (me.rendered) {
+                me[state ? 'addClsWithUI': 'removeClsWithUI'](me.pressedCls);
+            }
+            me.pressed = state;
+            if (!suppressEvent) {
+                me.fireEvent('toggle', me, state);
+                Ext.callback(me.toggleHandler, me.scope || me, [me, state]);
+            }
+        }
+        return me;
+    },
+    
+    maybeShowMenu: function(){
+        var me = this;
+        if (me.menu && !me.hasVisibleMenu() && !me.ignoreNextClick) {
+            me.showMenu();
+        }
+    },
+
+    
+    showMenu: function() {
+        var me = this;
+        if (me.rendered && me.menu) {
+            if (me.tooltip && me.getTipAttr() != 'title') {
+                Ext.tip.QuickTipManager.getQuickTip().cancelShow(me.btnEl);
+            }
+            if (me.menu.isVisible()) {
+                me.menu.hide();
+            }
+
+            me.menu.showBy(me.el, me.menuAlign, ((!Ext.isStrict && Ext.isIE) || Ext.isIE6) ? [-2, -2] : undefined);
+        }
+        return me;
+    },
+
+    
+    hideMenu: function() {
+        if (this.hasVisibleMenu()) {
+            this.menu.hide();
+        }
+        return this;
+    },
+
+    
+    hasVisibleMenu: function() {
+        var menu = this.menu;
+        return menu && menu.rendered && menu.isVisible();
+    },
+
+    
+    onRepeatClick: function(repeat, e) {
+        this.onClick(e);
+    },
+
+    
+    onClick: function(e) {
+        var me = this;
+        if (me.preventDefault || (me.disabled && me.getHref()) && e) {
+            e.preventDefault();
+        }
+        if (e.button !== 0) {
+            return;
+        }
+        if (!me.disabled) {
+            me.doToggle();
+            me.maybeShowMenu();
+            me.fireHandler(e);
+        }
+    },
+    
+    fireHandler: function(e){
+        var me = this,
+            handler = me.handler;
+            
+        if (me.fireEvent('click', me, e) !== false) {
+            if (handler) {
+                handler.call(me.scope || me, me, e);
+            }
+            me.blur();
+        }
+    },
+    
+    doToggle: function(){
+        var me = this;    
+        if (me.enableToggle && (me.allowDepress !== false || !me.pressed)) {
+            me.toggle();
+        }
+    },
+
+    
+    onMouseOver: function(e) {
+        var me = this;
+        if (!me.disabled && !e.within(me.el, true, true)) {
+            me.onMouseEnter(e);
+        }
+    },
+
+    
+    onMouseOut: function(e) {
+        var me = this;
+        if (!e.within(me.el, true, true)) {
+            if (me.overMenuTrigger) {
+                me.onMenuTriggerOut(e);
+            }
+            me.onMouseLeave(e);
+        }
+    },
+
+    
+    onMouseMove: function(e) {
+        var me = this,
+            el = me.el,
+            over = me.overMenuTrigger,
+            overlap, btnSize;
+
+        if (me.split) {
+            if (me.arrowAlign === 'right') {
+                overlap = e.getX() - el.getX();
+                btnSize = el.getWidth();
+            } else {
+                overlap = e.getY() - el.getY();
+                btnSize = el.getHeight();
+            }
+
+            if (overlap > (btnSize - me.getTriggerSize())) {
+                if (!over) {
+                    me.onMenuTriggerOver(e);
+                }
+            } else {
+                if (over) {
+                    me.onMenuTriggerOut(e);
+                }
+            }
+        }
+    },
+
+    
+    getTriggerSize: function() {
+        var me = this,
+            size = me.triggerSize,
+            side, sideFirstLetter, undef;
+
+        if (size === undef) {
+            side = me.arrowAlign;
+            sideFirstLetter = side.charAt(0);
+            size = me.triggerSize = me.el.getFrameWidth(sideFirstLetter) + me.btnWrap.getFrameWidth(sideFirstLetter) + me.frameSize[side];
+        }
+        return size;
+    },
+
+    
+    onMouseEnter: function(e) {
+        var me = this;
+        me.addClsWithUI(me.overCls);
+        me.fireEvent('mouseover', me, e);
+    },
+
+    
+    onMouseLeave: function(e) {
+        var me = this;
+        me.removeClsWithUI(me.overCls);
+        me.fireEvent('mouseout', me, e);
+    },
+
+    
+    onMenuTriggerOver: function(e) {
+        var me = this;
+        me.overMenuTrigger = true;
+        me.fireEvent('menutriggerover', me, me.menu, e);
+    },
+
+    
+    onMenuTriggerOut: function(e) {
+        var me = this;
+        delete me.overMenuTrigger;
+        me.fireEvent('menutriggerout', me, me.menu, e);
+    },
+
+    
+    enable : function(silent) {
+        var me = this;
+
+        me.callParent(arguments);
+
+        if (me.btnEl) {
+            me.btnEl.dom.disabled = false;
+        }
+        me.removeClsWithUI('disabled');
+
+        return me;
+    },
+
+    
+    disable : function(silent) {
+        var me = this;
+
+        me.callParent(arguments);
+
+        if (me.btnEl) {
+            me.btnEl.dom.disabled = true;
+        }
+        me.addClsWithUI('disabled');
+        me.removeClsWithUI(me.overCls);
+
+        
+        
+        if (me.btnInnerEl && (Ext.isIE6 || Ext.isIE7)) {
+            me.btnInnerEl.repaint();
+        }
+
+        return me;
+    },
+
+    
+    setScale: function(scale) {
+        var me = this,
+            ui = me.ui.replace('-' + me.scale, '');
+
+        
+        if (!Ext.Array.contains(me.allowedScales, scale)) {
+            throw('#setScale: scale must be an allowed scale (' + me.allowedScales.join(', ') + ')');
+        }
+
+        me.scale = scale;
+        me.setUI(ui);
+    },
+
+    
+    setUI: function(ui) {
+        var me = this;
+
+        
+        if (me.scale && !ui.match(me.scale)) {
+            ui = ui + '-' + me.scale;
+        }
+
+        me.callParent([ui]);
+
+        
+        
+    },
+
+    
+    onMouseDown: function(e) {
+        var me = this;
+        if (!me.disabled && e.button === 0) {
+            me.addClsWithUI(me.pressedCls);
+            me.doc.on('mouseup', me.onMouseUp, me);
+        }
+    },
+    
+    onMouseUp: function(e) {
+        var me = this;
+        if (e.button === 0) {
+            if (!me.pressed) {
+                me.removeClsWithUI(me.pressedCls);
+            }
+            me.doc.un('mouseup', me.onMouseUp, me);
+        }
+    },
+    
+    onMenuShow: function(e) {
+        var me = this;
+        me.ignoreNextClick = 0;
+        me.addClsWithUI(me.menuActiveCls);
+        me.fireEvent('menushow', me, me.menu);
+    },
+
+    
+    onMenuHide: function(e) {
+        var me = this;
+        me.removeClsWithUI(me.menuActiveCls);
+        me.ignoreNextClick = Ext.defer(me.restoreClick, 250, me);
+        me.fireEvent('menuhide', me, me.menu);
+    },
+
+    
+    restoreClick: function() {
+        this.ignoreNextClick = 0;
+    },
+
+    
+    onDownKey: function() {
+        var me = this;
+
+        if (!me.disabled) {
+            if (me.menu) {
+                me.showMenu();
+            }
+        }
+    },
+
+    
+    getPersistentPadding: function() {
+        var me = this,
+            reset = Ext.scopeResetCSS,
+            padding = me.persistentPadding,
+            btn, leftTop, btnEl, btnInnerEl, wrap;
+
+        
+        
+        if (!padding) {
+            padding = me.self.prototype.persistentPadding = [0, 0, 0, 0];
+            if (!Ext.isIE) {
+                btn = new Ext.button.Button({
+                    text: 'test',
+                    style: 'position:absolute;top:-999px;'
+                });
+                btn.el = Ext.DomHelper.append(Ext.resetElement, btn.getRenderTree(), true);
+                btn.applyChildEls(btn.el);
+                btnEl = btn.btnEl;
+                btnInnerEl = btn.btnInnerEl;
+                btnEl.setSize(null, null); 
+                leftTop = btnInnerEl.getOffsetsTo(btnEl);
+                padding[0] = leftTop[1];
+                padding[1] = btnEl.getWidth() - btnInnerEl.getWidth() - leftTop[0];
+                padding[2] = btnEl.getHeight() - btnInnerEl.getHeight() - leftTop[1];
+                padding[3] = leftTop[0];
+                
+                btn.destroy();
+                btn.el.remove();
+            }
+        }
+        return padding;
+    }
+}, function() {
+    var groups = {},
+        toggleGroup = function(btn, state) {
+            if (state) {
+                var g = groups[btn.toggleGroup],
+                    length = g.length,
+                    i;
+
+                for (i = 0; i < length; i++) {
+                    if (g[i] !== btn) {
+                        g[i].toggle(false);
+                    }
+                }
+            }
+        };
+
+    
+    Ext.ButtonToggleManager = {
+        register: function(btn) {
+            if (!btn.toggleGroup) {
+                return;
+            }
+            var group = groups[btn.toggleGroup];
+            if (!group) {
+                group = groups[btn.toggleGroup] = [];
+            }
+            group.push(btn);
+            btn.on('toggle', toggleGroup);
+        },
+
+        unregister: function(btn) {
+            if (!btn.toggleGroup) {
+                return;
+            }
+            var group = groups[btn.toggleGroup];
+            if (group) {
+                Ext.Array.remove(group, btn);
+                btn.un('toggle', toggleGroup);
+            }
+        },
+
+        
+        
+        
+        getPressed: function(group) {
+            var g = groups[group],
+                i = 0,
+                len;
+            if (g) {
+                for (len = g.length; i < len; i++) {
+                    if (g[i].pressed === true) {
+                        return g[i];
+                    }
+                }
+            }
+            return null;
+        }
+    };
+});
+
+
+Ext.define('Ext.layout.container.boxOverflow.Menu', {
+
+    
+
+    extend: 'Ext.layout.container.boxOverflow.None',
+    requires: ['Ext.toolbar.Separator', 'Ext.button.Button'],
+    alternateClassName: 'Ext.layout.boxOverflow.Menu',
+    
+    
+
+    
+
+    
+    noItemsMenuText : '<div class="' + Ext.baseCSSPrefix + 'toolbar-no-items">(None)</div>',
+
+    constructor: function(layout) {
+        var me = this;
+
+        me.callParent(arguments);
+
+        me.triggerButtonCls = me.triggerButtonCls || Ext.baseCSSPrefix + 'box-menu-' + layout.getNames().right;
+        
+        me.menuItems = [];
+    },
+
+    beginLayout: function (ownerContext) {
+        this.callParent(arguments);
+
+        
+        
+        this.clearOverflow(ownerContext);
+    },
+
+    beginLayoutCycle: function (ownerContext, firstCycle) {
+        this.callParent(arguments);
+
+        if (!firstCycle) {
+            
+            
+            this.clearOverflow(ownerContext);
+
+            this.layout.cacheChildItems(ownerContext);
+        }
+    },
+
+    onRemove: function(comp){
+        Ext.Array.remove(this.menuItems, comp);
+    },
+
+    
+    getSuffixConfig: function() {
+        var me = this,
+            layout = me.layout,
+            oid = layout.owner.id;
+
+        
+        me.menu = new Ext.menu.Menu({
+            listeners: {
+                scope: me,
+                beforeshow: me.beforeMenuShow
+            }
+        });
+
+        
+        me.menuTrigger = new Ext.button.Button({
+            id      : oid + '-menu-trigger',
+            cls     : Ext.layout.container.Box.prototype.innerCls + ' ' + me.triggerButtonCls,
+            hidden  : true,
+            ownerCt : layout.owner, 
+            ownerLayout: layout,
+            iconCls : Ext.baseCSSPrefix + me.getOwnerType(layout.owner) + '-more-icon',
+            ui      : layout.owner instanceof Ext.toolbar.Toolbar ? 'default-toolbar' : 'default',
+            menu    : me.menu,
+            getSplitCls: function() { return '';}
+        });
+
+        return me.menuTrigger.getRenderTree();
+    },
+    
+    getOverflowCls: function() {
+        return Ext.baseCSSPrefix + this.layout.direction + '-box-overflow-body';
+    },
+
+    handleOverflow: function(ownerContext) {
+        var me = this,
+            layout = me.layout,
+            names = layout.getNames(),
+            plan = ownerContext.state.boxPlan,
+            posArgs = [null, null];
+
+        me.showTrigger(ownerContext);
+
+        
+        
+        posArgs[names.heightIndex] = (plan.maxSize - me.menuTrigger[names.getHeight]()) / 2;
+        me.menuTrigger.setPosition.apply(me.menuTrigger, posArgs);
+
+        return {
+            reservedSpace: me.menuTrigger[names.getWidth]()
+        };
+    },
+
+    
+    captureChildElements: function() {
+        var menuTrigger = this.menuTrigger;
+        if (menuTrigger.rendering) {
+            menuTrigger.finishRender();
+        }
+    },
+
+    _asLayoutRoot: { isRoot: true },
+
+    
+    clearOverflow: function(ownerContext) {
+        var me = this,
+            items = me.menuItems,
+            item,
+            i = 0,
+            length = items.length,
+            owner = me.layout.owner,
+            asLayoutRoot = me._asLayoutRoot;
+
+        owner.suspendLayouts();
+        me.captureChildElements();
+        me.hideTrigger();
+        owner.resumeLayouts();
+
+        for (; i < length; i++) {
+            item = items[i];
+
+            
+            
+            item.suspendLayouts();
+            item.show();
+            item.resumeLayouts(asLayoutRoot);
+        }
+
+        items.length = 0;
+    },
+
+    
+    showTrigger: function(ownerContext) {
+        var me = this,
+            layout = me.layout,
+            owner = layout.owner,
+            names = layout.getNames(),
+            startProp = names.x,
+            sizeProp = names.width,
+            plan = ownerContext.state.boxPlan,
+            available = plan.targetSize[sizeProp],
+            childItems = ownerContext.childItems,
+            len = childItems.length,
+            menuTrigger = me.menuTrigger,
+            childContext,
+            comp, i, props;
+
+        
+        
+        menuTrigger.suspendLayouts();
+        menuTrigger.show();
+        menuTrigger.resumeLayouts(me._asLayoutRoot);
+
+        available -= me.menuTrigger.getWidth();
+
+        owner.suspendLayouts();
+
+        
+        
+        me.menuItems.length = 0;
+        for (i = 0; i < len; i++) {
+            childContext = childItems[i];
+            props = childContext.props;
+            if (props[startProp] + props[sizeProp] > available) {
+                comp = childContext.target;
+                me.menuItems.push(comp);
+                comp.hide();
+            }
+        }
+
+        owner.resumeLayouts();
+    },
+
+    
+    hideTrigger: function() {
+        var menuTrigger = this.menuTrigger;
+        if (menuTrigger) {
+            menuTrigger.hide();
+        }
+    },
+
+    
+    beforeMenuShow: function(menu) {
+        var me = this,
+            items = me.menuItems,
+            i = 0,
+            len   = items.length,
+            item,
+            prev,
+            needsSep = function(group, prev){
+                return group.isXType('buttongroup') && !(prev instanceof Ext.toolbar.Separator);
+            };
+
+        menu.suspendLayouts();
+        me.clearMenu();
+        menu.removeAll();
+
+        for (; i < len; i++) {
+            item = items[i];
+
+            
+            if (!i && (item instanceof Ext.toolbar.Separator)) {
+                continue;
+            }
+            if (prev && (needsSep(item, prev) || needsSep(prev, item))) {
+                menu.add('-');
+            }
+
+            me.addComponentToMenu(menu, item);
+            prev = item;
+        }
+
+        
+        if (menu.items.length < 1) {
+            menu.add(me.noItemsMenuText);
+        }
+        menu.resumeLayouts();
+    },
+    
+    
+    createMenuConfig : function(component, hideOnClick) {
+        var config = Ext.apply({}, component.initialConfig),
+            group  = component.toggleGroup;
+
+        Ext.copyTo(config, component, [
+            'iconCls', 'icon', 'itemId', 'disabled', 'handler', 'scope', 'menu'
+        ]);
+
+        Ext.apply(config, {
+            text       : component.overflowText || component.text,
+            hideOnClick: hideOnClick,
+            destroyMenu: false
+        });
+
+        
+        if (component.isFormField) {
+            config.value = component.getValue();
+
+            
+            if (!config.listeners) {
+                config.listeners = {};
+            }
+
+            
+            
+            
+            
+            
+            config.listeners.change = function(c, newVal, oldVal) {                            
+                component.setValue(newVal);
+            }
+        }
+
+        
+        else if (group || component.enableToggle) {
+            Ext.apply(config, {
+                iconAlign: 'right',
+                hideOnClick: false,
+                group  : group,
+                checked: component.pressed,
+                listeners: {
+                    checkchange: function(item, checked) {
+                        component.toggle(checked);
+                    }
+                }
+            });
+        }
+
+        delete config.ownerCt;
+        delete config.xtype;
+        delete config.id;
+        return config;
+    },
+
+    
+    addComponentToMenu : function(menu, component) {
+        var me = this,
+        i, items, iLen;
+
+        if (component instanceof Ext.toolbar.Separator) {
+            menu.add('-');
+        } else if (component.isComponent) {
+            if (component.isXType('splitbutton')) {
+                menu.add(me.createMenuConfig(component, true));
+
+            } else if (component.isXType('button')) {
+                menu.add(me.createMenuConfig(component, !component.menu));
+
+            } else if (component.isXType('buttongroup')) {
+                items = component.items.items;
+                iLen  = items.length;
+
+                for (i = 0; i < iLen; i++) {
+                    me.addComponentToMenu(menu, items[i]);
+                }
+            } else {
+                menu.add(Ext.create(Ext.getClassName(component), me.createMenuConfig(component)));
+            }
+        }
+    },
+
+    
+    clearMenu : function() {
+        var menu = this.menu,
+            items, i, iLen, item;
+        
+        if (menu && menu.items) {
+            items = menu.items.items;
+            iLen  = items.length;
+            
+            for (i = 0; i < iLen; i++) {
+                item = items[i];
+                if (item.setMenu) {
+                    item.setMenu(null);
+                }
+            }
+        }
+    },
+
+    
+    destroy: function() {
+        var trigger = this.menuTrigger;
+            
+        if (trigger && !this.layout.owner.items.contains(trigger)) {
+            
+            
+            delete trigger.ownerCt;
+        }
+        Ext.destroy(this.menu, trigger);
+    }
+});
+
+
+Ext.define('Ext.layout.container.boxOverflow.Scroller', {
+
+    
+
+    extend: 'Ext.layout.container.boxOverflow.None',
+    requires: ['Ext.util.ClickRepeater', 'Ext.Element'],
+    alternateClassName: 'Ext.layout.boxOverflow.Scroller',
+    mixins: {
+        observable: 'Ext.util.Observable'
+    },
+    
+    
+
+    
+    animateScroll: false,
+
+    
+    scrollIncrement: 20,
+
+    
+    wheelIncrement: 10,
+
+    
+    scrollRepeatInterval: 60,
+
+    
+    scrollDuration: 400,
+
+    
+
+    
+
+    
+    scrollerCls: Ext.baseCSSPrefix + 'box-scroller',
+
+    
+
+    
+
+    constructor: function(layout, config) {
+        var me = this;
+
+        me.layout = layout;
+        Ext.apply(me, config || {});
+
+        
+        me.mixins.observable.constructor.call(me);
+
+        me.addEvents(
+            
+            'scroll'
+        );
+        me.scrollPosition = 0;
+        me.scrollSize = 0;
+    },
+
+    getPrefixConfig: function() {
+        var me = this;
+        me.initCSSClasses();
+        return {
+            cls: Ext.layout.container.Box.prototype.innerCls + ' ' + me.beforeCtCls,
+            cn : {
+                id : me.layout.owner.id + '-before-scroller',
+                cls: me.scrollerCls + ' ' + me.beforeScrollerCls,
+                style: 'display:none'
+            }
+        };
+    },
+
+    getSuffixConfig: function() {
+        var me = this;
+        return {
+            cls: Ext.layout.container.Box.prototype.innerCls + ' ' + me.afterCtCls,
+            cn : {
+                id : me.layout.owner.id + '-after-scroller',
+                cls: me.scrollerCls + ' ' + me.afterScrollerCls,
+                style: 'display:none'
+            }
+        };
+    },
+
+    getOverflowCls: function() {
+        return Ext.baseCSSPrefix + this.layout.direction + '-box-overflow-body';
+    },
+
+    initCSSClasses: function() {
+        var me = this,
+            prefix = Ext.baseCSSPrefix,
+            layout = me.layout,
+            names = layout.getNames(),
+            leftName = names.left,
+            rightName = names.right,
+            type = me.getOwnerType(layout.owner);
+
+        me.beforeCtCls = me.beforeCtCls || prefix + 'box-scroller-' + leftName;
+        me.afterCtCls  = me.afterCtCls  || prefix + 'box-scroller-' + rightName;
+        
+        me.beforeScrollerCls = me.beforeScrollerCls || prefix + type + '-scroll-' + leftName;
+        me.afterScrollerCls  = me.afterScrollerCls  || prefix + type + '-scroll-' + rightName;
+    },
+
+    beginLayout: function (ownerContext) {
+        var layout = this.layout,
+            names = layout.getNames();
+
+        ownerContext.innerCtScrollPos = layout.innerCt.dom['scroll' + names.leftCap];
+
+        this.callParent(arguments);
+    },
+
+    completeLayout: function (ownerContext) {
+        
+        this.scrollSize = ownerContext.props['content'+this.layout.getNames().widthCap];
+
+        this.callParent(arguments);
+    },
+    
+    finishedLayout: function(ownerContext) {
+        var me = this,
+            layout = me.layout,
+            names = layout.getNames(),
+            scrollPos = Math.min(me.getMaxScrollPosition(), ownerContext.innerCtScrollPos);
+
+        layout.innerCt.dom['scroll' + names.leftCap] = scrollPos;
+    },
+
+    handleOverflow: function(ownerContext) {
+        var me = this,
+            layout = me.layout,
+            names = layout.getNames(),
+            methodName = 'get' + names.widthCap;
+
+        me.captureChildElements();
+        me.showScrollers();
+
+        return {
+            reservedSpace: me.beforeCt[methodName]() + me.afterCt[methodName]()
+        };
+    },
+
+    
+    captureChildElements: function() {
+        var me = this,
+            el = me.layout.owner.el,
+            before,
+            after;
+
+        
+        if (!me.beforeCt) {
+            before = me.beforeScroller = el.getById(me.layout.owner.id + '-before-scroller');
+            after = me.afterScroller = el.getById(me.layout.owner.id + '-after-scroller');
+            me.beforeCt = before.up('');
+            me.afterCt = after.up('');
+            me.createWheelListener();
+
+            before.addClsOnOver(me.beforeScrollerCls + '-hover');
+            after.addClsOnOver(me.afterScrollerCls + '-hover');
+
+            before.setVisibilityMode(Ext.Element.DISPLAY);
+            after.setVisibilityMode(Ext.Element.DISPLAY);
+
+            me.beforeRepeater = new Ext.util.ClickRepeater(before, {
+                interval: me.scrollRepeatInterval,
+                handler : me.scrollLeft,
+                scope   : me
+            });
+
+            me.afterRepeater = new Ext.util.ClickRepeater(after, {
+                interval: me.scrollRepeatInterval,
+                handler : me.scrollRight,
+                scope   : me
+            });
+        }
+    },
+
+    
+    createWheelListener: function() {
+        this.layout.innerCt.on({
+            mousewheel: function(e) {
+                this.scrollBy(e.getWheelDelta() * this.wheelIncrement * -1, false);
+            },
+            stopEvent: true,
+            scope: this
+        });
+    },
+
+    
+    clearOverflow: function () {
+        var layout = this.layout;
+
+        this.hideScrollers();
+    },
+
+    
+    showScrollers: function() {
+        var me = this;
+
+        me.captureChildElements();
+        me.beforeScroller.show();
+        me.afterScroller.show();
+        me.updateScrollButtons();
+        me.layout.owner.addClsWithUI('scroller');
+        
+    },
+
+    
+    hideScrollers: function() {
+        var me = this;
+
+        if (me.beforeScroller !== undefined) {
+            me.beforeScroller.hide();
+            me.afterScroller.hide();
+            me.layout.owner.removeClsWithUI('scroller');
+            
+        }
+    },
+
+    
+    destroy: function() {
+        var me = this;
+
+        Ext.destroy(me.beforeRepeater, me.afterRepeater, me.beforeScroller, me.afterScroller, me.beforeCt, me.afterCt);
+    },
+
+    
+    scrollBy: function(delta, animate) {
+        this.scrollTo(this.getScrollPosition() + delta, animate);
+    },
+
+    
+    getScrollAnim: function() {
+        return {
+            duration: this.scrollDuration, 
+            callback: this.updateScrollButtons, 
+            scope   : this
+        };
+    },
+
+    
+    updateScrollButtons: function() {
+        var me = this,
+            beforeMeth,
+            afterMeth,
+            beforeCls,
+            afterCls;
+            
+        if (me.beforeScroller === undefined || me.afterScroller === undefined) {
+            return;
+        }
+
+        beforeMeth = me.atExtremeBefore()  ? 'addCls' : 'removeCls';
+        afterMeth  = me.atExtremeAfter() ? 'addCls' : 'removeCls';
+        beforeCls  = me.beforeScrollerCls + '-disabled';
+        afterCls   = me.afterScrollerCls  + '-disabled';
+
+        me.beforeScroller[beforeMeth](beforeCls);
+        me.afterScroller[afterMeth](afterCls);
+        me.scrolling = false;
+    },
+
+    
+    atExtremeBefore: function() {
+        return !this.getScrollPosition();
+    },
+
+    
+    scrollLeft: function() {
+        this.scrollBy(-this.scrollIncrement, false);
+    },
+
+    
+    scrollRight: function() {
+        this.scrollBy(this.scrollIncrement, false);
+    },
+
+    
+    getScrollPosition: function(){
+        var me = this,
+            layout = me.layout,
+            result;
+
+        
+        if (me.hasOwnProperty('scrollPosition')) {
+            result = me.scrollPosition;
+        } else {
+            result = parseInt(layout.innerCt.dom['scroll' + layout.getNames().leftCap], 10) || 0;
+        }
+        return result;
+    },
+
+    
+    getMaxScrollPosition: function() {
+        var me = this,
+            layout = me.layout,
+            names = layout.getNames(),
+            maxScrollPos = me.scrollSize - layout.innerCt['get'+names.widthCap]();
+
+        return (maxScrollPos < 0) ? 0 : maxScrollPos;
+    },
+
+    
+    atExtremeAfter: function() {
+        return this.getScrollPosition() >= this.getMaxScrollPosition();
+    },
+
+    
+    scrollTo: function(position, animate) {
+        var me = this,
+            layout = me.layout,
+            names = layout.getNames(),
+            oldPosition = me.getScrollPosition(),
+            newPosition = Ext.Number.constrain(position, 0, me.getMaxScrollPosition());
+
+        if (newPosition != oldPosition && !me.scrolling) {
+            delete me.scrollPosition;
+            if (animate === undefined) {
+                animate = me.animateScroll;
+            }
+
+            layout.innerCt.scrollTo(names.left, newPosition, animate ? me.getScrollAnim() : false);
+            if (animate) {
+                me.scrolling = true;
+            } else {
+                me.updateScrollButtons();
+            }
+            me.fireEvent('scroll', me, newPosition, animate ? me.getScrollAnim() : false);
+        }
+    },
+
+    
+    scrollToItem: function(item, animate) {
+        var me = this,
+            layout = me.layout,
+            names = layout.getNames(),
+            visibility,
+            box,
+            newPos;
+
+        item = me.getItem(item);
+        if (item !== undefined) {
+            visibility = me.getItemVisibility(item);
+            if (!visibility.fullyVisible) {
+                box  = item.getBox(true, true);
+                newPos = box[names.x];
+                if (visibility.hiddenEnd) {
+                    newPos -= (me.layout.innerCt['get' + names.widthCap]() - box[names.width]);
+                }
+                me.scrollTo(newPos, animate);
+            }
+        }
+    },
+
+    
+    getItemVisibility: function(item) {
+        var me          = this,
+            box         = me.getItem(item).getBox(true, true),
+            layout      = me.layout,
+            names       = layout.getNames(),
+            itemStart   = box[names.x],
+            itemEnd     = itemStart + box[names.width],
+            scrollStart = me.getScrollPosition(),
+            scrollEnd   = scrollStart + layout.innerCt['get' + names.widthCap]();
+
+        return {
+            hiddenStart : itemStart < scrollStart,
+            hiddenEnd   : itemEnd > scrollEnd,
+            fullyVisible: itemStart > scrollStart && itemEnd < scrollEnd
+        };
+    }
+});
+
+
+Ext.define('Ext.util.Offset', {
+
+    
+
+    statics: {
+        fromObject: function(obj) {
+            return new this(obj.x, obj.y);
+        }
+    },
+
+    
+
+    constructor: function(x, y) {
+        this.x = (x != null && !isNaN(x)) ? x : 0;
+        this.y = (y != null && !isNaN(y)) ? y : 0;
+
+        return this;
+    },
+
+    copy: function() {
+        return new Ext.util.Offset(this.x, this.y);
+    },
+
+    copyFrom: function(p) {
+        this.x = p.x;
+        this.y = p.y;
+    },
+
+    toString: function() {
+        return "Offset[" + this.x + "," + this.y + "]";
+    },
+
+    equals: function(offset) {
+
+        return (this.x == offset.x && this.y == offset.y);
+    },
+
+    round: function(to) {
+        if (!isNaN(to)) {
+            var factor = Math.pow(10, to);
+            this.x = Math.round(this.x * factor) / factor;
+            this.y = Math.round(this.y * factor) / factor;
+        } else {
+            this.x = Math.round(this.x);
+            this.y = Math.round(this.y);
+        }
+    },
+
+    isZero: function() {
+        return this.x == 0 && this.y == 0;
+    }
+});
+
+
+Ext.define('Ext.util.Region', {
+
+    
+
+    requires: ['Ext.util.Offset'],
+
+    statics: {
+        
+        getRegion: function(el) {
+            return Ext.fly(el).getPageBox(true);
+        },
+
+        
+        from: function(o) {
+            return new this(o.top, o.right, o.bottom, o.left);
+        }
+    },
+
+    
+
+    
+    constructor : function(t, r, b, l) {
+        var me = this;
+        me.y = me.top = me[1] = t;
+        me.right = r;
+        me.bottom = b;
+        me.x = me.left = me[0] = l;
+    },
+
+    
+    contains : function(region) {
+        var me = this;
+        return (region.x >= me.x &&
+                region.right <= me.right &&
+                region.y >= me.y &&
+                region.bottom <= me.bottom);
+
+    },
+
+    
+    intersect : function(region) {
+        var me = this,
+            t = Math.max(me.y, region.y),
+            r = Math.min(me.right, region.right),
+            b = Math.min(me.bottom, region.bottom),
+            l = Math.max(me.x, region.x);
+
+        if (b > t && r > l) {
+            return new this.self(t, r, b, l);
+        }
+        else {
+            return false;
+        }
+    },
+
+    
+    union : function(region) {
+        var me = this,
+            t = Math.min(me.y, region.y),
+            r = Math.max(me.right, region.right),
+            b = Math.max(me.bottom, region.bottom),
+            l = Math.min(me.x, region.x);
+
+        return new this.self(t, r, b, l);
+    },
+
+    
+    constrainTo : function(r) {
+        var me = this,
+            constrain = Ext.Number.constrain;
+        me.top = me.y = constrain(me.top, r.y, r.bottom);
+        me.bottom = constrain(me.bottom, r.y, r.bottom);
+        me.left = me.x = constrain(me.left, r.x, r.right);
+        me.right = constrain(me.right, r.x, r.right);
+        return me;
+    },
+
+    
+    adjust : function(t, r, b, l) {
+        var me = this;
+        me.top = me.y += t;
+        me.left = me.x += l;
+        me.right += r;
+        me.bottom += b;
+        return me;
+    },
+
+    
+    getOutOfBoundOffset: function(axis, p) {
+        if (!Ext.isObject(axis)) {
+            if (axis == 'x') {
+                return this.getOutOfBoundOffsetX(p);
+            } else {
+                return this.getOutOfBoundOffsetY(p);
+            }
+        } else {
+            p = axis;
+            var d = new Ext.util.Offset();
+            d.x = this.getOutOfBoundOffsetX(p.x);
+            d.y = this.getOutOfBoundOffsetY(p.y);
+            return d;
+        }
+
+    },
+
+    
+    getOutOfBoundOffsetX: function(p) {
+        if (p <= this.x) {
+            return this.x - p;
+        } else if (p >= this.right) {
+            return this.right - p;
+        }
+
+        return 0;
+    },
+
+    
+    getOutOfBoundOffsetY: function(p) {
+        if (p <= this.y) {
+            return this.y - p;
+        } else if (p >= this.bottom) {
+            return this.bottom - p;
+        }
+
+        return 0;
+    },
+
+    
+    isOutOfBound: function(axis, p) {
+        if (!Ext.isObject(axis)) {
+            if (axis == 'x') {
+                return this.isOutOfBoundX(p);
+            } else {
+                return this.isOutOfBoundY(p);
+            }
+        } else {
+            p = axis;
+            return (this.isOutOfBoundX(p.x) || this.isOutOfBoundY(p.y));
+        }
+    },
+
+    
+    isOutOfBoundX: function(p) {
+        return (p < this.x || p > this.right);
+    },
+
+    
+    isOutOfBoundY: function(p) {
+        return (p < this.y || p > this.bottom);
+    },
+
+    
+    restrict: function(axis, p, factor) {
+        if (Ext.isObject(axis)) {
+            var newP;
+
+            factor = p;
+            p = axis;
+
+            if (p.copy) {
+                newP = p.copy();
+            }
+            else {
+                newP = {
+                    x: p.x,
+                    y: p.y
+                };
+            }
+
+            newP.x = this.restrictX(p.x, factor);
+            newP.y = this.restrictY(p.y, factor);
+            return newP;
+        } else {
+            if (axis == 'x') {
+                return this.restrictX(p, factor);
+            } else {
+                return this.restrictY(p, factor);
+            }
+        }
+    },
+
+    
+    restrictX : function(p, factor) {
+        if (!factor) {
+            factor = 1;
+        }
+
+        if (p <= this.x) {
+            p -= (p - this.x) * factor;
+        }
+        else if (p >= this.right) {
+            p -= (p - this.right) * factor;
+        }
+        return p;
+    },
+
+    
+    restrictY : function(p, factor) {
+        if (!factor) {
+            factor = 1;
+        }
+
+        if (p <= this.y) {
+            p -= (p - this.y) * factor;
+        }
+        else if (p >= this.bottom) {
+            p -= (p - this.bottom) * factor;
+        }
+        return p;
+    },
+
+    
+    getSize: function() {
+        return {
+            width: this.right - this.x,
+            height: this.bottom - this.y
+        };
+    },
+
+    
+    copy: function() {
+        return new this.self(this.y, this.right, this.bottom, this.x);
+    },
+
+    
+    copyFrom: function(p) {
+        var me = this;
+        me.top = me.y = me[1] = p.y;
+        me.right = p.right;
+        me.bottom = p.bottom;
+        me.left = me.x = me[0] = p.x;
+
+        return this;
+    },
+
+    
+    toString: function() {
+        return "Region[" + this.top + "," + this.right + "," + this.bottom + "," + this.left + "]";
+    },
+
+    
+    translateBy: function(x, y) {
+        if (arguments.length == 1) {
+            y = x.y;
+            x = x.x;
+        }
+        var me = this;
+        me.top = me.y += y;
+        me.right += x;
+        me.bottom += y;
+        me.left = me.x += x;
+
+        return me;
+    },
+
+    
+    round: function() {
+        var me = this;
+        me.top = me.y = Math.round(me.y);
+        me.right = Math.round(me.right);
+        me.bottom = Math.round(me.bottom);
+        me.left = me.x = Math.round(me.x);
+
+        return me;
+    },
+
+    
+    equals: function(region) {
+        return (this.top == region.top && this.right == region.right && this.bottom == region.bottom && this.left == region.left);
+    }
+});
+
+
+
+
+
+Ext.define('Ext.dd.DragDropManager', {
+    singleton: true,
+
+    requires: ['Ext.util.Region'],
+
+    uses: ['Ext.tip.QuickTipManager'],
+
+    
+    alternateClassName: ['Ext.dd.DragDropMgr', 'Ext.dd.DDM'],
+
+    
+    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,
+
+    
+    notifyOccluded: false,
+
+    
+    _execOnAll: function(sMethod, args) {
+        var i, j, oDD;
+        for (i in this.ids) {
+            for (j in this.ids[i]) {
+                oDD = this.ids[i][j];
+                if (! this.isTypeOfDD(oDD)) {
+                    continue;
+                }
+                oDD[sMethod].apply(oDD, args);
+            }
+        }
+    },
+
+    
+    _onLoad: function() {
+
+        this.init();
+
+        var Event = Ext.EventManager;
+        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] && 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 = [],
+            i, j, dd;
+        for (i in p_oDD.groups) {
+            for (j in this.ids[i]) {
+                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),
+            i, len;
+        for (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) {
+        var me = this,
+            i, dd;
+        for (i in this.ids) {
+            dd = this.ids[i][id];
+            if (dd instanceof Ext.dd.DDTarget) {
+                return dd;
+            }
+        }
+        return null;
+    },
+
+    
+    handleMouseDown: function(e, oDD) {
+        if(Ext.tip.QuickTipManager){
+            Ext.tip.QuickTipManager.ddDisable();
+        }
+        if(this.dragCurrent){
+            
+            
+            this.handleMouseUp(e);
+        }
+
+        this.currentTarget = e.getTarget();
+        this.dragCurrent = oDD;
+
+        var el = oDD.getEl();
+        
+        
+        
+        
+        
+        if (Ext.isIE && el.setCapture) {
+            el.setCapture();
+        }
+
+        
+        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.DragDropManager;
+                    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) {
+        var current = this.dragCurrent;
+        
+        if(Ext.tip && Ext.tip.QuickTipManager){
+            Ext.tip.QuickTipManager.ddEnable();
+        }
+        if (!current) {
+            return;
+        }
+        
+        
+        if (Ext.isIE && document.releaseCapture) {
+            document.releaseCapture();
+        }
+
+        clearTimeout(this.clickTimeout);
+
+        if (this.dragThreshMet) {
+            this.fireEvents(e, true);
+        }
+
+        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) {
+        var me = this,
+            diffX,
+            diffY;
+            
+        if (!me.dragCurrent) {
+            return true;
+        }
+
+        if (!me.dragThreshMet) {
+            diffX = Math.abs(me.startX - e.getPageX());
+            diffY = Math.abs(me.startY - e.getPageY());
+            if (diffX > me.clickPixelThresh ||
+                        diffY > me.clickPixelThresh) {
+                me.startDrag(me.startX, me.startY);
+            }
+        }
+
+        if (me.dragThreshMet) {
+            me.dragCurrent.b4Drag(e);
+            me.dragCurrent.onDrag(e);
+            if(!me.dragCurrent.moveOnly){
+                me.fireEvents(e, false);
+            }
+        }
+
+        me.stopEvent(e);
+
+        return true;
+    },
+
+    
+    fireEvents: function(e, isDrop) {
+        var me = this,
+            dragCurrent = me.dragCurrent,
+            mousePoint = e.getPoint(),
+            overTarget,
+            overTargetEl,
+            allTargets = [],
+            oldOvers  = [],  
+            outEvts   = [],
+            overEvts  = [],
+            dropEvts  = [],
+            enterEvts = [],
+            needsSort,
+            i,
+            len,
+            sGroup;
+
+        
+        
+        if (!dragCurrent || dragCurrent.isLocked()) {
+            return;
+        }
+
+        
+        
+        for (i in me.dragOvers) {
+
+            overTarget = me.dragOvers[i];
+
+            if (! me.isTypeOfDD(overTarget)) {
+                continue;
+            }
+
+            if (! this.isOverTarget(mousePoint, overTarget, me.mode)) {
+                outEvts.push( overTarget );
+            }
+
+            oldOvers[i] = true;
+            delete me.dragOvers[i];
+        }
+
+        
+        
+        
+        for (sGroup in dragCurrent.groups) {
+
+            if ("string" != typeof sGroup) {
+                continue;
+            }
+
+            
+            for (i in me.ids[sGroup]) {
+                overTarget = me.ids[sGroup][i];
+
+                
+                
+                
+                
+                
+                
+                if (me.isTypeOfDD(overTarget) &&
+                        (overTargetEl = overTarget.getEl()) &&
+                        (overTarget.isTarget) &&
+                        (!overTarget.isLocked()) &&
+                        (Ext.fly(overTargetEl).isVisible(true)) &&
+                        ((overTarget != dragCurrent) || (dragCurrent.ignoreSelf === false))) {
+
+                    
+                    if ((overTarget.zIndex = me.getZIndex(overTargetEl)) !== -1) {
+                        needsSort = true;
+                    }
+                    allTargets.push(overTarget);
+                }
+            }
+        }
+
+        
+        if (needsSort) {
+            Ext.Array.sort(allTargets, me.byZIndex);
+        }
+
+        
+        
+        for (i = 0, len = allTargets.length; i < len; i++) {
+            overTarget = allTargets[i];
+
+            
+            if (me.isOverTarget(mousePoint, overTarget, me.mode)) {
+                
+                if (isDrop) {
+                    dropEvts.push( overTarget );
+                
+                } else {
+
+                    
+                    if (!oldOvers[overTarget.id]) {
+                        enterEvts.push( overTarget );
+                    
+                    } else {
+                        overEvts.push( overTarget );
+                    }
+                    me.dragOvers[overTarget.id] = overTarget;
+                }
+
+                
+                if (!me.notifyOccluded) {
+                    break;
+                }
+            }
+        }
+
+        if (me.mode) {
+            if (outEvts.length) {
+                dragCurrent.b4DragOut(e, outEvts);
+                dragCurrent.onDragOut(e, outEvts);
+            }
+
+            if (enterEvts.length) {
+                dragCurrent.onDragEnter(e, enterEvts);
+            }
+
+            if (overEvts.length) {
+                dragCurrent.b4DragOver(e, overEvts);
+                dragCurrent.onDragOver(e, overEvts);
+            }
+
+            if (dropEvts.length) {
+                dragCurrent.b4DragDrop(e, dropEvts);
+                dragCurrent.onDragDrop(e, dropEvts);
+            }
+
+        } else {
+            
+            for (i=0, len=outEvts.length; i<len; ++i) {
+                dragCurrent.b4DragOut(e, outEvts[i].id);
+                dragCurrent.onDragOut(e, outEvts[i].id);
+            }
+
+            
+            for (i=0,len=enterEvts.length; i<len; ++i) {
+                
+                dragCurrent.onDragEnter(e, enterEvts[i].id);
+            }
+
+            
+            for (i=0,len=overEvts.length; i<len; ++i) {
+                dragCurrent.b4DragOver(e, overEvts[i].id);
+                dragCurrent.onDragOver(e, overEvts[i].id);
+            }
+
+            
+            for (i=0, len=dropEvts.length; i<len; ++i) {
+                dragCurrent.b4DragDrop(e, dropEvts[i].id);
+                dragCurrent.onDragDrop(e, dropEvts[i].id);
+            }
+
+        }
+
+        
+        if (isDrop && !dropEvts.length) {
+            dragCurrent.onInvalidDrop(e);
+        }
+
+    },
+
+    
+    getZIndex: function(element) {
+        var body = document.body,
+            z,
+            zIndex = -1;
+
+        element = Ext.getDom(element);
+        while (element !== body) {
+            if (!isNaN(z = Number(Ext.fly(element).getStyle('zIndex')))) {
+                zIndex = z;
+            }
+            element = element.parentNode;
+        }
+        return zIndex;
+    },
+
+    
+    byZIndex: function(d1, d2) {
+        return d1.zIndex < d2.zIndex;
+    },
+
+    
+    getBestMatch: function(dds) {
+        var winner = null,
+            len = dds.length,
+            i, dd;
+        
+        
+           
+        
+        
+
+
+        if (len == 1) {
+            winner = dds[0];
+        } else {
+            
+            for (i=0; i<len; ++i) {
+                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) {
+        var sGroup, i, oDD, loc;
+        for (sGroup in groups) {
+            if ("string" != typeof sGroup) {
+                continue;
+            }
+            for (i in this.ids[sGroup]) {
+                oDD = this.ids[sGroup][i];
+
+                if (this.isTypeOfDD(oDD)) {
+                
+                    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;
+        }
+
+        
+        
+        if (oDD.getRegion) {
+            return oDD.getRegion();
+        }
+
+        var el = oDD.getEl(), pos, x1, x2, y1, y2, t, r, b, l;
+
+        try {
+            pos= Ext.Element.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.util.Region(t, r, b, l);
+    },
+
+    
+    isOverTarget: function(pt, oTarget, intersect) {
+        
+        var loc = this.locationCache[oTarget.id],
+            dc, pos, el, curRegion, overlap;
+        if (!loc || !this.useCache) {
+            loc = this.getLocation(oTarget);
+            this.locationCache[oTarget.id] = loc;
+
+        }
+
+        if (!loc) {
+            return false;
+        }
+
+        oTarget.cursorIsOver = loc.contains( pt );
+
+        
+        
+        
+        
+        
+        dc = this.dragCurrent;
+        if (!dc || !dc.getTargetCoord ||
+                (!intersect && !dc.constrainX && !dc.constrainY)) {
+            return oTarget.cursorIsOver;
+        }
+
+        oTarget.overlap = null;
+
+        
+        
+        
+        
+        pos = dc.getTargetCoord(pt.x, pt.y);
+
+        el = dc.getDragEl();
+        curRegion = new Ext.util.Region(pos.y,
+                                               pos.x + el.offsetWidth,
+                                               pos.y + el.offsetHeight,
+                                               pos.x );
+
+        overlap = curRegion.intersect(loc);
+
+        if (overlap) {
+            oTarget.overlap = overlap;
+            return (intersect) ? true : oTarget.cursorIsOver;
+        } else {
+            return false;
+        }
+    },
+
+    
+    _onUnload: function(e, me) {
+        Ext.dd.DragDropManager.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.Element.getX(el);
+    },
+
+    
+    getPosY: function(el) {
+        return Ext.Element.getY(el);
+    },
+
+    
+    swapNode: function(n1, n2) {
+        if (n1.swapNode) {
+            n1.swapNode(n2);
+        } else {
+            var p = n2.parentNode,
+                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 doc   = window.document,
+            docEl = doc.documentElement,
+            body  = doc.body,
+            top   = 0,
+            left  = 0;
+
+        if (Ext.isGecko4) {
+            top  = window.scrollYOffset;
+            left = window.scrollXOffset;
+        } else {
+            if (docEl && (docEl.scrollTop || docEl.scrollLeft)) {
+                top  = docEl.scrollTop;
+                left = docEl.scrollLeft;
+            } else if (body) {
+                top  = body.scrollTop;
+                left = body.scrollLeft;
+            }
+        }
+        return {
+            top: top,
+            left: left
+        };
+    },
+
+    
+    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.Element.getXY(targetEl);
+        Ext.Element.setXY(moveEl, aCoord);
+    },
+
+    
+    numericSort: function(a, b) {
+        return (a - b);
+    },
+
+    
+    _timeoutCount: 0,
+
+    
+    _addListeners: function() {
+        if ( document ) {
+            this._onLoad();
+        } else {
+            if (this._timeoutCount <= 2000) {
+                setTimeout(this._addListeners, 10);
+                if (document && document.body) {
+                    this._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;
+    }
+}, function() {
+    this._addListeners();
+});
+
+
+Ext.define('Ext.layout.container.Box', {
+
+    
+
+    alias: ['layout.box'],
+    extend: 'Ext.layout.container.Container',
+    alternateClassName: 'Ext.layout.BoxLayout',
+
+    requires: [
+        'Ext.layout.container.boxOverflow.None',
+        'Ext.layout.container.boxOverflow.Menu',
+        'Ext.layout.container.boxOverflow.Scroller',
+        'Ext.util.Format',
+        'Ext.dd.DragDropManager'
+    ],
+
+    
+
+    
+    defaultMargins: {
+        top: 0,
+        right: 0,
+        bottom: 0,
+        left: 0
+    },
+
+    
+    padding: 0,
+
+    
+    pack: 'start',
+
+    
+    flex: undefined,
+
+    
+    stretchMaxPartner: undefined,
+
+    type: 'box',
+    scrollOffset: 0,
+    itemCls: Ext.baseCSSPrefix + 'box-item',
+    targetCls: Ext.baseCSSPrefix + 'box-layout-ct',
+    innerCls: Ext.baseCSSPrefix + 'box-inner',
+
+    
+    
+    availableSpaceOffset: 0,
+
+    
+    reserveOffset: true,
+
+    manageMargins: true,
+
+    childEls: [
+        'innerCt',
+        'targetEl'
+    ],
+
+    renderTpl: [
+        '{%var oc,l=values.$comp.layout,oh=l.overflowHandler;',
+        'if (oh.getPrefixConfig!==Ext.emptyFn) {',
+            'if(oc=oh.getPrefixConfig())dh.generateMarkup(oc, out)',
+        '}%}',
+        '<div id="{ownerId}-innerCt" class="{[l.innerCls]} {[oh.getOverflowCls()]}" role="presentation">',
+            '<div id="{ownerId}-targetEl" style="position:absolute;',
+                    
+                    
+                    
+                    
+                    
+                    'width:20000px;',
+                    
+                    
+                    
+                    
+                    
+                    'left:0px;top:0px;',
+                    
+                    
+                    'height:1px">',
+                '{%this.renderBody(out, values)%}',
+            '</div>',
+        '</div>',
+        '{%if (oh.getSuffixConfig!==Ext.emptyFn) {',
+            'if(oc=oh.getSuffixConfig())dh.generateMarkup(oc, out)',
+        '}%}',
+        {
+            disableFormats: true,
+            definitions: 'var dh=Ext.DomHelper;'
+        }
+    ],
+
+    constructor: function(config) {
+        var me = this,
+            type;
+
+        me.callParent(arguments);
+
+        
+        me.flexSortFn = Ext.Function.bind(me.flexSort, me);
+
+        me.initOverflowHandler();
+
+        type = typeof me.padding;
+        if (type == 'string' || type == 'number') {
+            me.padding = Ext.util.Format.parseBox(me.padding);
+            me.padding.height = me.padding.top  + me.padding.bottom;
+            me.padding.width  = me.padding.left + me.padding.right;
+        }
+    },
+
+    getNames: function () {
+        return this.names;
+    },
+
+    
+    
+    _percentageRe: /^\s*(\d+(?:\.\d*)?)\s*[%]\s*$/,
+
+    getItemSizePolicy: function (item, ownerSizeModel) {
+        var me = this,
+            policy = me.sizePolicy,
+            align = me.align,
+            flex = item.flex,
+            key = align,
+            names = me.names,
+            width = item[names.width],
+            height = item[names.height],
+            percentageRe = me._percentageRe,
+            percentageWidth = percentageRe.test(width),
+            isStretch = (align == 'stretch');
+            
+        if ((isStretch || flex || percentageWidth) && !ownerSizeModel) {
+            ownerSizeModel = me.owner.getSizeModel();
+        }
+
+        if (isStretch) {
+            
+            
+            if (!percentageRe.test(height) && ownerSizeModel[names.height].shrinkWrap) {
+                key = 'stretchmax';
+                
+                
+                
+            }
+        } else if (align != 'stretchmax') {
+            if (percentageRe.test(height)) {
+                
+                
+                key = 'stretch';
+            } else {
+                key = '';
+            }
+        }
+
+        if (flex || percentageWidth) {
+            
+            
+            if (!ownerSizeModel[names.width].shrinkWrap) {
+                policy = policy.flex; 
+            }
+        }
+
+        return policy[key];
+    },
+
+    flexSort: function (a, b) {
+        var maxWidthName = this.getNames().maxWidth,
+            infiniteValue = Infinity;
+
+        a = a.target[maxWidthName] || infiniteValue;
+        b = b.target[maxWidthName] || infiniteValue;
+
+        
+        if (!isFinite(a) && !isFinite(b)) {
+            return 0;
+        }
+
+        return a - b;
+    },
+
+    isItemBoxParent: function (itemContext) {
+        return true;
+    },
+
+    isItemShrinkWrap: function (item) {
+        return true;
+    },
+
+    
+    minSizeSortFn: function(a, b) {
+        return b.available - a.available;
+    },
+
+    roundFlex: function(width) {
+        return Math.ceil(width);
+    },
+
+    
+    beginCollapse: function(child) {
+        var me = this;
+
+        if (me.direction === 'vertical' && child.collapsedVertical()) {
+            child.collapseMemento.capture(['flex']);
+            delete child.flex;
+        } else if (me.direction === 'horizontal' && child.collapsedHorizontal()) {
+            child.collapseMemento.capture(['flex']);
+            delete child.flex;
+        }
+    },
+
+    
+    beginExpand: function(child) {
+
+        
+        child.collapseMemento.restore(['flex']);
+    },
+
+    beginLayout: function (ownerContext) {
+        var me = this,
+            smp = me.owner.stretchMaxPartner,
+            style = me.innerCt.dom.style,
+            names = me.getNames();
+
+        ownerContext.boxNames = names;
+
+        
+        
+        me.overflowHandler.beginLayout(ownerContext);
+
+        
+        if (typeof smp === 'string') {
+            smp = Ext.getCmp(smp) || me.owner.query(smp)[0];
+        }
+
+        ownerContext.stretchMaxPartner = smp && ownerContext.context.getCmp(smp);
+
+        me.callParent(arguments);
+
+        ownerContext.innerCtContext = ownerContext.getEl('innerCt', me);
+
+        
+        me.scrollParallel = !!(me.owner.autoScroll || me.owner[names.overflowX]);
+
+        
+        me.scrollPerpendicular = !!(me.owner.autoScroll || me.owner[names.overflowY]);
+
+        
+        if (me.scrollParallel) {
+            me.scrollPos = me.owner.getTargetEl().dom[names.scrollLeft];
+        }
+
+        
+        style.width = '';
+        style.height = '';
+    },
+
+    beginLayoutCycle: function (ownerContext, firstCycle) {
+        var me = this,
+            align = me.align,
+            names = ownerContext.boxNames,
+            pack = me.pack,
+            heightModelName = names.heightModel;
+
+        
+        
+        me.overflowHandler.beginLayoutCycle(ownerContext, firstCycle);
+
+        me.callParent(arguments);
+
+        
+        
+
+        ownerContext.parallelSizeModel      = ownerContext[names.widthModel];
+        ownerContext.perpendicularSizeModel = ownerContext[heightModelName];
+
+        ownerContext.boxOptions = {
+            align: align = {
+                stretch:    align == 'stretch',
+                stretchmax: align == 'stretchmax',
+                center:     align == names.center
+            },
+            pack: pack = {
+                center: pack == 'center',
+                end:    pack == 'end'
+            }
+        };
+
+        
+        
+        
+        
+        
+
+        if (align.stretch && ownerContext.perpendicularSizeModel.shrinkWrap) {
+            align.stretchmax = true;
+            align.stretch = false;
+        }
+
+        
+        align.nostretch = !(align.stretch || align.stretchmax);
+
+        
+        
+        
+
+        if (ownerContext.parallelSizeModel.shrinkWrap) {
+            pack.center = pack.end = false;
+        }
+
+        me.cacheFlexes(ownerContext);
+
+        
+        
+        
+        if (Ext.isWebKit) {
+            me.targetEl.setWidth(20000);
+        }
+    },
+
+    
+    cacheFlexes: function (ownerContext) {
+        var me = this,
+            names = ownerContext.boxNames,
+            widthModelName = names.widthModel,
+            heightModelName = names.heightModel,
+            nostretch = ownerContext.boxOptions.align.nostretch,
+            totalFlex = 0,
+            childItems = ownerContext.childItems,
+            i = childItems.length,
+            flexedItems = [],
+            minWidth = 0,
+            minWidthName = names.minWidth,
+            percentageRe = me._percentageRe,
+            percentageWidths = 0,
+            percentageHeights = 0,
+            child, childContext, flex, match;
+
+        while (i--) {
+            childContext = childItems[i];
+            child = childContext.target;
+
+            
+            
+            
+            if (childContext[widthModelName].calculated) {
+                childContext.flex = flex = child.flex;
+                if (flex) {
+                    totalFlex += flex;
+                    flexedItems.push(childContext);
+                    minWidth += child[minWidthName] || 0;
+                } else { 
+                    match = percentageRe.exec(child[names.width]);
+                    childContext.percentageParallel = parseFloat(match[1]) / 100;
+                    ++percentageWidths;
+                }
+            }
+            
+            
+
+            if (nostretch && childContext[heightModelName].calculated) {
+                
+                
+                match = percentageRe.exec(child[names.height]);
+                childContext.percentagePerpendicular = parseFloat(match[1]) / 100;
+                ++percentageHeights;
+            }
+        }
+
+        ownerContext.flexedItems = flexedItems;
+        ownerContext.flexedMinSize = minWidth;
+        ownerContext.totalFlex = totalFlex;
+        ownerContext.percentageWidths = percentageWidths;
+        ownerContext.percentageHeights = percentageHeights;
+
+        
+        
+        
+        Ext.Array.sort(flexedItems, me.flexSortFn);
+    },
+
+    calculate: function(ownerContext) {
+        var me = this,
+            targetSize = me.getContainerSize(ownerContext),
+            names = ownerContext.boxNames,
+            state = ownerContext.state,
+            plan = state.boxPlan || (state.boxPlan = {});
+
+        plan.targetSize = targetSize;
+
+        
+        if (!ownerContext.parallelSizeModel.shrinkWrap && !targetSize[names.gotWidth]) {
+            me.done = false;
+            return;
+        }
+
+        if (!state.parallelDone) {
+            state.parallelDone = me.calculateParallel(ownerContext, names, plan);
+        }
+
+        if (!state.perpendicularDone) {
+            state.perpendicularDone = me.calculatePerpendicular(ownerContext, names, plan);
+        }
+
+        if (state.parallelDone && state.perpendicularDone) {
+            
+            
+            
+            
+            if (me.owner.dock && (Ext.isIE6 || Ext.isIE7 || Ext.isIEQuirks) && !me.owner.width && !me.horizontal) {
+                plan.isIEVerticalDock = true;
+                plan.calculatedWidth = plan.maxSize + ownerContext.getPaddingInfo().width + ownerContext.getFrameInfo().width;
+            }
+
+            me.publishInnerCtSize(ownerContext, me.reserveOffset ? me.availableSpaceOffset : 0);
+
+            
+            if (me.done && ownerContext.childItems.length > 1 && ownerContext.boxOptions.align.stretchmax && !state.stretchMaxDone) {
+                me.calculateStretchMax(ownerContext, names, plan);
+                state.stretchMaxDone = true;
+            }
+        } else {
+            me.done = false;
+        }
+    },
+
+    calculateParallel: function(ownerContext, names, plan) {
+        var me = this,
+            widthName = names.width,
+            childItems = ownerContext.childItems,
+            leftName = names.left,
+            rightName = names.right,
+            setWidthName = names.setWidth,
+            childItemsLength = childItems.length,
+            flexedItems = ownerContext.flexedItems,
+            flexedItemsLength = flexedItems.length,
+            pack = ownerContext.boxOptions.pack,
+            padding = me.padding,
+            containerWidth = plan.targetSize[widthName],
+            totalMargin = 0,
+            left = padding[leftName],
+            nonFlexWidth = left + padding[rightName] + me.scrollOffset +
+                                    (me.reserveOffset ? me.availableSpaceOffset : 0),
+            scrollbarWidth = Ext.getScrollbarSize()[names.width],
+            i, childMargins, remainingWidth, remainingFlex, childContext, flex, flexedWidth,
+            contentWidth, mayNeedScrollbarAdjust, childWidth, percentageSpace;
+
+        
+        
+        
+        
+        
+        
+        if (scrollbarWidth &&
+            me.scrollPerpendicular &&
+            ownerContext.parallelSizeModel.shrinkWrap &&
+            !ownerContext.boxOptions.align.stretch &&
+            !ownerContext.perpendicularSizeModel.shrinkWrap) {
+
+            
+            
+            
+            if (!ownerContext.state.perpendicularDone) {
+                return false;
+            }
+            mayNeedScrollbarAdjust = true;
+        }
+
+        
+        for (i = 0; i < childItemsLength; ++i) {
+            childContext = childItems[i];
+            childMargins = childContext.marginInfo || childContext.getMarginInfo();
+
+            totalMargin += childMargins[widthName];
+
+            if (!childContext[names.widthModel].calculated) {
+                childWidth = childContext.getProp(widthName);
+                nonFlexWidth += childWidth; 
+                if (isNaN(nonFlexWidth)) {
+                    return false;
+                }
+            }
+        }
+
+        nonFlexWidth += totalMargin;
+        if (ownerContext.percentageWidths) {
+            percentageSpace = containerWidth - totalMargin;
+            if (isNaN(percentageSpace)) {
+                return false;
+            }
+
+            for (i = 0; i < childItemsLength; ++i) {
+                childContext = childItems[i];
+                if (childContext.percentageParallel) {
+                    childWidth = Math.ceil(percentageSpace * childContext.percentageParallel);
+                    childWidth = childContext.setWidth(childWidth);
+                    nonFlexWidth += childWidth;
+                }
+            }
+        }
+
+        
+
+        if (ownerContext.parallelSizeModel.shrinkWrap) {
+            plan.availableSpace = 0;
+            plan.tooNarrow = false;
+        } else {
+            plan.availableSpace = containerWidth - nonFlexWidth;
+
+            
+            plan.tooNarrow = plan.availableSpace < ownerContext.flexedMinSize;
+            if (plan.tooNarrow && Ext.getScrollbarSize()[names.height] && me.scrollParallel && ownerContext.state.perpendicularDone) {
+                ownerContext.state.perpendicularDone = false;
+                for (i = 0; i < childItemsLength; ++i) {
+                    childItems[i].invalidate();
+                }
+            }
+        }
+
+        contentWidth = nonFlexWidth;
+        remainingWidth = plan.availableSpace;
+        remainingFlex = ownerContext.totalFlex;
+
+        
+        for (i = 0; i < flexedItemsLength; i++) {
+            childContext = flexedItems[i];
+            flex         = childContext.flex;
+            flexedWidth  = me.roundFlex((flex / remainingFlex) * remainingWidth);
+            flexedWidth  = childContext[setWidthName](flexedWidth); 
+
+            
+
+            contentWidth   += flexedWidth;
+            
+            remainingWidth  = Math.max(0, remainingWidth - flexedWidth); 
+            remainingFlex  -= flex;
+        }
+
+        if (pack.center) {
+            left += remainingWidth / 2;
+
+            
+            if (left < 0) {
+                left = 0;
+            }
+        } else if (pack.end) {
+            left += remainingWidth;
+        }
+
+        
+        for (i = 0; i < childItemsLength; ++i) {
+            childContext = childItems[i];
+            childMargins = childContext.marginInfo; 
+
+            left += childMargins[leftName];
+
+            childContext.setProp(names.x, left);
+
+            
+            
+            
+            
+            left += childMargins[rightName] + childContext.props[widthName];
+        }
+
+        contentWidth += ownerContext.targetContext.getPaddingInfo()[widthName];
+
+        
+        ownerContext.state.contentWidth = contentWidth; 
+
+        
+        
+        if (mayNeedScrollbarAdjust &&
+            (ownerContext.peek(names.contentHeight) > plan.targetSize[names.height])) {
+            contentWidth += scrollbarWidth;
+            ownerContext[names.hasOverflowY] = true;
+
+            
+            ownerContext.target.componentLayout[names.setWidthInDom] = true;
+
+            
+            
+            
+            
+            ownerContext[names.invalidateScrollY] = (Ext.isStrict && Ext.isIE8);
+        }
+        ownerContext[names.setContentWidth](contentWidth);
+
+        return true;
+    },
+
+    calculatePerpendicular: function(ownerContext, names, plan) {
+        var me = this,
+            heightShrinkWrap = ownerContext.perpendicularSizeModel.shrinkWrap,
+            targetSize = plan.targetSize,
+            childItems = ownerContext.childItems,
+            childItemsLength = childItems.length,
+            mmax = Math.max,
+            heightName = names.height,
+            setHeightName = names.setHeight,
+            topName = names.top,
+            topPositionName = names.y,
+            padding = me.padding,
+            top = padding[topName],
+            availHeight = targetSize[heightName] - top - padding[names.bottom],
+            align = ownerContext.boxOptions.align,
+            isStretch    = align.stretch, 
+            isStretchMax = align.stretchmax,
+            isCenter     = align.center,
+            maxHeight = 0,
+            hasPercentageSizes = 0,
+            scrollbarHeight = Ext.getScrollbarSize().height,
+            childTop, i, childHeight, childMargins, diff, height, childContext,
+            stretchMaxPartner, stretchMaxChildren, shrinkWrapParallelOverflow, 
+            percentagePerpendicular;
+
+        if (isStretch || (isCenter && !heightShrinkWrap)) {
+            if (isNaN(availHeight)) {
+                return false;
+            }
+        }
+
+        
+        
+        
+        
+        
+        
+        if (me.scrollParallel && plan.tooNarrow) {
+            if (heightShrinkWrap) {
+                shrinkWrapParallelOverflow = true;
+            } else {
+                availHeight -= scrollbarHeight;
+                plan.targetSize[heightName] -= scrollbarHeight;
+            }
+        }
+
+        if (isStretch) {
+            height = availHeight; 
+        } else {
+            for (i = 0; i < childItemsLength; i++) {
+                childContext = childItems[i];
+                childMargins = (childContext.marginInfo || childContext.getMarginInfo())[heightName];
+
+                if (!(percentagePerpendicular = childContext.percentagePerpendicular)) {
+                    childHeight = childContext.getProp(heightName);
+                } else {
+                    ++hasPercentageSizes;
+                    if (heightShrinkWrap) {
+                        
+                        
+                        continue;
+                    } else {
+                        childHeight = percentagePerpendicular * availHeight - childMargins;
+                        childHeight = childContext[names.setHeight](childHeight);
+                    }
+                }
+
+                
+                if (isNaN(maxHeight = mmax(maxHeight, childHeight + childMargins,
+                                           childContext.target[names.minHeight] || 0))) {
+                    return false; 
+                }
+            }
+
+            
+            
+            if (shrinkWrapParallelOverflow) {
+                maxHeight += scrollbarHeight;
+                ownerContext[names.hasOverflowX] = true;
+
+                
+                ownerContext.target.componentLayout[names.setHeightInDom] = true;
+
+                
+                
+                
+                
+                ownerContext[names.invalidateScrollX] = (Ext.isStrict && Ext.isIE8);
+            }
+
+            
+            
+            stretchMaxPartner = ownerContext.stretchMaxPartner;
+            if (stretchMaxPartner) {
+                
+                ownerContext.setProp('maxChildHeight', maxHeight);
+                stretchMaxChildren = stretchMaxPartner.childItems;
+                
+                if (stretchMaxChildren && stretchMaxChildren.length) {
+                    maxHeight = mmax(maxHeight, stretchMaxPartner.getProp('maxChildHeight'));
+                    if (isNaN(maxHeight)) {
+                        return false;
+                    }
+                }
+            }
+
+            ownerContext[names.setContentHeight](maxHeight + me.padding[heightName] +
+                    ownerContext.targetContext.getPaddingInfo()[heightName]);
+
+            
+            
+            
+            if (shrinkWrapParallelOverflow) {
+                maxHeight -= scrollbarHeight;
+            }
+            plan.maxSize = maxHeight;
+
+            if (isStretchMax) {
+                height = maxHeight;
+            } else if (isCenter || hasPercentageSizes) {
+                height = heightShrinkWrap ? maxHeight : mmax(availHeight, maxHeight);
+
+                
+                
+                
+                
+                height -= ownerContext.innerCtContext.getBorderInfo()[heightName];
+            }
+        }
+
+        for (i = 0; i < childItemsLength; i++) {
+            childContext = childItems[i];
+            childMargins = childContext.marginInfo || childContext.getMarginInfo();
+
+            childTop = top + childMargins[topName];
+
+            if (isStretch) {
+                childContext[setHeightName](height - childMargins[heightName]);
+            } else {
+                percentagePerpendicular = childContext.percentagePerpendicular;
+                if (heightShrinkWrap && percentagePerpendicular) {
+                    childMargins = childContext.marginInfo || childContext.getMarginInfo();
+                    childHeight = percentagePerpendicular * height - childMargins[heightName];
+                    childHeight = childContext.setHeight(childHeight);
+                }
+
+                if (isCenter) {
+                    diff = height - childContext.props[heightName];
+                    if (diff > 0) {
+                        childTop = top + Math.round(diff / 2);
+                    }
+                }
+            }
+
+            childContext.setProp(topPositionName, childTop);
+        }
+
+        return true;
+    },
+
+    calculateStretchMax: function (ownerContext, names, plan) {
+        var me = this,
+            heightName = names.height,
+            widthName = names.width,
+            childItems = ownerContext.childItems,
+            length = childItems.length,
+            height = plan.maxSize,
+            onBeforeInvalidateChild = me.onBeforeInvalidateChild,
+            onAfterInvalidateChild = me.onAfterInvalidateChild,
+            childContext, props, i, childHeight;
+
+        for (i = 0; i < length; ++i) {
+            childContext = childItems[i];
+
+            props = childContext.props;
+            childHeight = height - childContext.getMarginInfo()[heightName];
+
+            if (childHeight != props[heightName] ||   
+                childContext[names.heightModel].constrained) { 
+                
+                
+                
+                
+                
+                
+                
+                childContext.invalidate({
+                    before: onBeforeInvalidateChild,
+                    after: onAfterInvalidateChild,
+                    layout: me,
+                    
+                    childWidth: props[widthName],
+                    
+                    childHeight: childHeight,
+                    childX: props.x,
+                    childY: props.y,
+                    names: names
+                });
+            }
+        }
+    },
+
+    completeLayout: function(ownerContext) {
+        var me = this,
+            names = ownerContext.boxNames,
+            invalidateScrollX = ownerContext.invalidateScrollX,
+            invalidateScrollY = ownerContext.invalidateScrollY,
+            dom, el, overflowX, overflowY, styles;
+
+        me.overflowHandler.completeLayout(ownerContext);
+
+        if (invalidateScrollX || invalidateScrollY) {
+            el = me.getTarget();
+            dom = el.dom;
+            styles = dom.style;
+
+            if (invalidateScrollX) {
+                
+                overflowX = el.getStyle('overflowX');
+                if (overflowX == 'auto') {
+                    
+                    overflowX = styles.overflowX;
+                    styles.overflowX = 'scroll'; 
+                } else {
+                    invalidateScrollX = false; 
+                }
+            }
+
+            if (invalidateScrollY) {
+                
+                overflowY = el.getStyle('overflowY');
+                if (overflowY == 'auto') {
+                    
+                    overflowY = styles.overflowY;
+                    styles.overflowY = 'scroll'; 
+                } else {
+                    invalidateScrollY = false; 
+                }
+            }
+
+            if (invalidateScrollX || invalidateScrollY) { 
+                
+                dom.scrollWidth;
+
+                if (invalidateScrollX) {
+                    styles.overflowX = overflowX; 
+                }
+                if (invalidateScrollY) {
+                    styles.overflowY = overflowY; 
+                }
+            }
+        }
+
+        
+        if (me.scrollParallel) {
+            me.owner.getTargetEl().dom[names.scrollLeft] = me.scrollPos;
+        }
+    },
+
+    finishedLayout: function(ownerContext) {
+        this.overflowHandler.finishedLayout(ownerContext);
+        this.callParent(arguments);
+
+        
+        
+        
+        
+        
+        
+        if (Ext.isWebKit) {
+            this.targetEl.setWidth(ownerContext.innerCtContext.props.width);
+        }
+    },
+
+    onBeforeInvalidateChild: function (childContext, options) {
+        
+        var heightModelName = options.names.heightModel;
+
+        
+        
+        
+        
+        if (!childContext[heightModelName].constrainedMax) {
+            
+            
+            childContext[heightModelName] = Ext.layout.SizeModel.calculated;
+        }
+    },
+
+    onAfterInvalidateChild: function (childContext, options) {
+        
+        var names = options.names,
+            scrollbarSize = Ext.getScrollbarSize(),
+            childHeight = options.childHeight,
+            childWidth = options.childWidth;
+
+        childContext.setProp('x', options.childX);
+        childContext.setProp('y', options.childY);
+
+        if (childContext[names.heightModel].calculated) {
+            
+            
+            childContext[names.setHeight](childHeight);
+        }
+
+        if (childContext[names.widthModel].calculated) {
+            childContext[names.setWidth](childWidth);
+        }
+    },
+
+    publishInnerCtSize: function(ownerContext, reservedSpace) {
+        var me = this,
+            names = ownerContext.boxNames,
+            heightName = names.height,
+            widthName = names.width,
+            align = ownerContext.boxOptions.align,
+            dock = me.owner.dock,
+            padding = me.padding,
+            plan = ownerContext.state.boxPlan,
+            targetSize = plan.targetSize,
+            height = targetSize[heightName],
+            innerCtContext = ownerContext.innerCtContext,
+            innerCtWidth = (ownerContext.parallelSizeModel.shrinkWrap || (plan.tooNarrow && me.scrollParallel)
+                    ? ownerContext.state.contentWidth
+                    : targetSize[widthName]) - (reservedSpace || 0),
+            innerCtHeight;
+
+        if (align.stretch) {
+            innerCtHeight = height;
+        } else {
+            innerCtHeight = plan.maxSize + padding[names.top] + padding[names.bottom] + innerCtContext.getBorderInfo()[heightName];
+
+            if (!ownerContext.perpendicularSizeModel.shrinkWrap && align.center) {
+                innerCtHeight = Math.max(height, innerCtHeight);
+            }
+        }
+
+        innerCtContext[names.setWidth](innerCtWidth);
+        innerCtContext[names.setHeight](innerCtHeight);
+
+        
+        if (isNaN(innerCtWidth + innerCtHeight)) {
+            me.done = false;
+        }
+
+        
+        
+        
+        
+        
+        
+        if (plan.calculatedWidth && (dock == 'left' || dock == 'right')) {
+            
+            ownerContext.setWidth(plan.calculatedWidth, true, true);
+        }
+    },
+
+    onRemove: function(comp){
+        var me = this;
+        me.callParent(arguments);
+        if (me.overflowHandler) {
+            me.overflowHandler.onRemove(comp);
+        }
+        if (comp.layoutMarginCap == me.id) {
+            delete comp.layoutMarginCap;
+        }
+    },
+
+    
+    initOverflowHandler: function() {
+        var me = this,
+            handler = me.overflowHandler,
+            handlerType,
+            constructor;
+
+        if (typeof handler == 'string') {
+            handler = {
+                type: handler
+            };
+        }
+
+        handlerType = 'None';
+        if (handler && handler.type !== undefined) {
+            handlerType = handler.type;
+        }
+
+        constructor = Ext.layout.container.boxOverflow[handlerType];
+        if (constructor[me.type]) {
+            constructor = constructor[me.type];
+        }
+
+        me.overflowHandler = Ext.create('Ext.layout.container.boxOverflow.' + handlerType, me, handler);
+    },
+
+    
+    
+    getRenderTarget: function() {
+        return this.targetEl;
+    },
+
+    
+    
+    getElementTarget: function() {
+        return this.innerCt;
+    },
+
+
+    
+    destroy: function() {
+        Ext.destroy(this.innerCt, this.overflowHandler);
+        this.callParent(arguments);
+    }
+});
+
+
+Ext.define('Ext.layout.container.HBox', {
+
+    
+
+    alias: ['layout.hbox'],
+    extend: 'Ext.layout.container.Box',
+    alternateClassName: 'Ext.layout.HBoxLayout',
+
+    
+
+    
+    align: 'top', 
+
+    type : 'hbox',
+
+    direction: 'horizontal',
+
+    horizontal: true,
+
+    names: {
+        
+        lr: 'lr',
+        left: 'left',
+        leftCap: 'Left',
+        right: 'right',
+        position: 'left',
+        width: 'width',
+        contentWidth: 'contentWidth',
+        minWidth: 'minWidth',
+        maxWidth: 'maxWidth',
+        widthCap: 'Width',
+        widthModel: 'widthModel',
+        widthIndex: 0,
+        x: 'x',
+        scrollLeft: 'scrollLeft',
+        overflowX: 'overflowX',
+        hasOverflowX: 'hasOverflowX',
+        invalidateScrollX: 'invalidateScrollX',
+
+        
+        center: 'middle',
+        top: 'top',
+        topPosition: 'top',
+        bottom: 'bottom',
+        height: 'height',
+        contentHeight: 'contentHeight',
+        minHeight: 'minHeight',
+        maxHeight: 'maxHeight',
+        heightCap: 'Height',
+        heightModel: 'heightModel',
+        heightIndex: 1,
+        y: 'y',
+        scrollTop: 'scrollTop',
+        overflowY: 'overflowY',
+        hasOverflowY: 'hasOverflowY',
+        invalidateScrollY: 'invalidateScrollY',
+
+        
+        getWidth: 'getWidth',
+        getHeight: 'getHeight',
+        setWidth: 'setWidth',
+        setHeight: 'setHeight',
+        gotWidth: 'gotWidth',
+        gotHeight: 'gotHeight',
+        setContentWidth: 'setContentWidth',
+        setContentHeight: 'setContentHeight',
+        setWidthInDom: 'setWidthInDom',
+        setHeightInDom: 'setHeightInDom'
+    },
+
+    sizePolicy: {
+        flex: {
+            '': {
+                setsWidth: 1,
+                setsHeight: 0
+            },
+            stretch: {
+                setsWidth: 1,
+                setsHeight: 1
+            },
+            stretchmax: {
+                readsHeight: 1,
+                setsWidth: 1,
+                setsHeight: 1
+            }
+        },
+        '': {
+            setsWidth: 0,
+            setsHeight: 0
+        },
+        stretch: {
+            setsWidth: 0,
+            setsHeight: 1
+        },
+        stretchmax: {
+            readsHeight: 1,
+            setsWidth: 0,
+            setsHeight: 1
+        }
+    }            
+});
+
+
+Ext.define('Ext.layout.container.VBox', {
+
+    
+
+    alias: ['layout.vbox'],
+    extend: 'Ext.layout.container.Box',
+    alternateClassName: 'Ext.layout.VBoxLayout',
+
+    
+
+    
+    align : 'left', 
+
+    type: 'vbox',
+
+    direction: 'vertical',
+
+    horizontal: false,
+
+    names: {
+        
+        lr: 'tb',
+        left: 'top',
+        leftCap: 'Top',
+        right: 'bottom',
+        position: 'top',
+        width: 'height',
+        contentWidth: 'contentHeight',
+        minWidth: 'minHeight',
+        maxWidth: 'maxHeight',
+        widthCap: 'Height',
+        widthModel: 'heightModel',
+        widthIndex: 1,
+        x: 'y',
+        scrollLeft: 'scrollTop',
+        overflowX: 'overflowY',
+        hasOverflowX: 'hasOverflowY',
+        invalidateScrollX: 'invalidateScrollY',
+
+        
+        center: 'center',
+        top: 'left',
+        topPosition: 'left',
+        bottom: 'right',
+        height: 'width',
+        contentHeight: 'contentWidth',
+        minHeight: 'minWidth',
+        maxHeight: 'maxWidth',
+        heightCap: 'Width',
+        heightModel: 'widthModel',
+        heightIndex: 0,
+        y: 'x',
+        scrollTop: 'scrollLeft',
+        overflowY: 'overflowX',
+        hasOverflowY: 'hasOverflowX',
+        invalidateScrollY: 'invalidateScrollX',
+
+        
+        getWidth: 'getHeight',
+        getHeight: 'getWidth',
+        setWidth: 'setHeight',
+        setHeight: 'setWidth',
+        gotWidth: 'gotHeight',
+        gotHeight: 'gotWidth',
+        setContentWidth: 'setContentHeight',
+        setContentHeight: 'setContentWidth',
+        setWidthInDom: 'setHeightInDom',
+        setHeightInDom: 'setWidthInDom'
+    },
+
+    sizePolicy: {
+        flex: {
+            '': {
+                setsWidth: 0,
+                setsHeight: 1
+            },
+            stretch: {
+                setsWidth: 1,
+                setsHeight: 1
+            },
+            stretchmax: {
+                readsWidth: 1,
+                setsWidth: 1,
+                setsHeight: 1
+            }
+        },
+        '': {
+            setsWidth: 0,
+            setsHeight: 0
+        },
+        stretch: {
+            setsWidth: 1,
+            setsHeight: 0
+        },
+        stretchmax: {
+            readsWidth: 1,
+            setsWidth: 1,
+            setsHeight: 0
+        }
+    }
+});
+
+
+Ext.define('Ext.toolbar.Toolbar', {
+    extend: 'Ext.container.Container',
+    requires: [
+        'Ext.toolbar.Fill',
+        'Ext.layout.container.HBox',
+        'Ext.layout.container.VBox'
+    ],
+    uses: [
+        'Ext.toolbar.Separator'
+    ],
+    alias: 'widget.toolbar',
+    alternateClassName: 'Ext.Toolbar',
+
+    
+    isToolbar: true,
+    baseCls  : Ext.baseCSSPrefix + 'toolbar',
+    ariaRole : 'toolbar',
+
+    defaultType: 'button',
+
+    
+    vertical: false,
+
+    
+
+    
+    enableOverflow: false,
+
+    
+    menuTriggerCls: Ext.baseCSSPrefix + 'toolbar-more-icon',
+    
+    
+    trackMenus: true,
+
+    itemCls: Ext.baseCSSPrefix + 'toolbar-item',
+
+    statics: {
+        shortcuts: {
+            '-' : 'tbseparator',
+            ' ' : 'tbspacer'
+        },
+
+        shortcutsHV: {
+            
+            0: {
+                '->': { xtype: 'tbfill', height: 0 }
+            },
+            
+            1: {
+                '->': { xtype: 'tbfill', width: 0 }
+            }
+        }
+    },
+
+    initComponent: function() {
+        var me = this,
+            keys;
+
+        
+        if (!me.layout && me.enableOverflow) {
+            me.layout = { overflowHandler: 'Menu' };
+        }
+
+        if (me.dock === 'right' || me.dock === 'left') {
+            me.vertical = true;
+        }
+
+        me.layout = Ext.applyIf(Ext.isString(me.layout) ? {
+            type: me.layout
+        } : me.layout || {}, {
+            type: me.vertical ? 'vbox' : 'hbox',
+            align: me.vertical ? 'stretchmax' : 'middle'
+        });
+
+        if (me.vertical) {
+            me.addClsWithUI('vertical');
+        }
+
+        
+        if (me.ui === 'footer') {
+            me.ignoreBorderManagement = true;
+        }
+
+        me.callParent();
+
+        
+        me.addEvents('overflowchange');
+    },
+
+    getRefItems: function(deep) {
+        var me = this,
+            items = me.callParent(arguments),
+            layout = me.layout,
+            handler;
+
+        if (deep && me.enableOverflow) {
+            handler = layout.overflowHandler;
+            if (handler && handler.menu) {
+                items = items.concat(handler.menu.getRefItems(deep));
+            }
+        }
+        return items;
+    },
+
+    
+
+    
+    lookupComponent: function(c) {
+        if (typeof c == 'string') {
+            var T = Ext.toolbar.Toolbar,
+                shortcut = T.shortcutsHV[this.vertical ? 1 : 0][c] || T.shortcuts[c];
+
+            if (typeof shortcut == 'string') {
+                c = {
+                    xtype: shortcut
+                };
+            } else if (shortcut) {
+                c = Ext.apply({}, shortcut);
+            } else {
+                c = {
+                    xtype: 'tbtext',
+                    text: c
+                };
+            }
+
+            this.applyDefaults(c);
+        }
+
+        return this.callParent(arguments);
+    },
+
+    
+    applyDefaults: function(c) {
+        if (!Ext.isString(c)) {
+            c = this.callParent(arguments);
+        }
+        return c;
+    },
+
+    
+    trackMenu: function(item, remove) {
+        if (this.trackMenus && item.menu) {
+            var method = remove ? 'mun' : 'mon',
+                me = this;
+
+            me[method](item, 'mouseover', me.onButtonOver, me);
+            me[method](item, 'menushow', me.onButtonMenuShow, me);
+            me[method](item, 'menuhide', me.onButtonMenuHide, me);
+        }
+    },
+
+    
+    constructButton: function(item) {
+        return item.events ? item
+                : Ext.widget(item.split ? 'splitbutton' : this.defaultType, item);
+    },
+
+    
+    onBeforeAdd: function(component) {
+        if (component.is('field') || (component.is('button') && this.ui != 'footer')) {
+            component.ui = component.ui + '-toolbar';
+        }
+
+        
+        if (component instanceof Ext.toolbar.Separator) {
+            component.setUI((this.vertical) ? 'vertical' : 'horizontal');
+        }
+
+        this.callParent(arguments);
+    },
+
+    
+    onAdd: function(component) {
+        this.callParent(arguments);
+        this.trackMenu(component);
+    },
+    
+    
+    onRemove: function(c) {
+        this.callParent(arguments);
+        this.trackMenu(c, true);
+    },
+    
+    getChildItemsToDisable: function() {
+        return this.items.getRange();   
+    },
+
+    
+    onButtonOver: function(btn){
+        if (this.activeMenuBtn && this.activeMenuBtn != btn) {
+            this.activeMenuBtn.hideMenu();
+            btn.showMenu();
+            this.activeMenuBtn = btn;
+        }
+    },
+
+    
+    onButtonMenuShow: function(btn) {
+        this.activeMenuBtn = btn;
+    },
+
+    
+    onButtonMenuHide: function(btn) {
+        delete this.activeMenuBtn;
+    }
+});
+
+
+Ext.define('Ext.container.DockingContainer', {
+
+    
+
+    requires: ['Ext.util.MixedCollection', 'Ext.Element' ],
+
+    
+
+    isDockingContainer: true,
+
+    
+    defaultDockWeights: {
+        top:    { render: 1, visual: 1 },
+        left:   { render: 3, visual: 5 },
+        right:  { render: 5, visual: 7 },
+        bottom: { render: 7, visual: 3 }
+    },
+
+    
+    
+    
+    
+    dockOrder: {
+        top: -1,
+        left: -1,
+        right: 1,
+        bottom: 1
+    },
+
+    
+    addDocked : function(items, pos) {
+        var me = this,
+            i = 0,
+            item, length;
+
+        items = me.prepareItems(items);
+        length = items.length;
+
+        for (; i < length; i++) {
+            item = items[i];
+            item.dock = item.dock || 'top';
+
+            if (pos !== undefined) {
+                me.dockedItems.insert(pos + i, item);
+            } else {
+                me.dockedItems.add(item);
+            }
+            if (item.onAdded !== Ext.emptyFn) {
+                item.onAdded(me, i);
+            }
+            if (me.onDockedAdd !== Ext.emptyFn) {
+                me.onDockedAdd(item);
+            }
+        }
+
+        if (me.rendered && !me.suspendLayout) {
+            me.updateLayout();
+        }
+        return items;
+    },
+
+    destroyDockedItems: function(){
+        var dockedItems = this.dockedItems,
+            c;
+
+        if (dockedItems) {
+            while ((c = dockedItems.first())) {
+                this.removeDocked(c, true);
+            }
+        }
+    },
+
+    doRenderDockedItems: function (out, renderData, after) {
+        
+        
+        
+
+        
+        
+        
+        
+        var me = renderData.$comp,
+            layout = me.componentLayout,
+            items,
+            tree;
+
+        if (layout.getDockedItems && !renderData.$skipDockedItems) {
+            items = layout.getDockedItems('render', !after);
+            tree = items && layout.getItemsRenderTree(items);
+
+            if (tree) {
+                Ext.DomHelper.generateMarkup(tree, out);
+            }
+        }
+    },
+
+    
+    getDockedComponent: function(comp) {
+        if (Ext.isObject(comp)) {
+            comp = comp.getItemId();
+        }
+        return this.dockedItems.get(comp);
+    },
+
+    
+    getDockedItems : function(selector, beforeBody) {
+        var dockedItems = this.getComponentLayout().getDockedItems('render', beforeBody);
+
+        if (selector && dockedItems.length) {
+            dockedItems = Ext.ComponentQuery.query(selector, dockedItems);
+        }
+
+        return dockedItems;
+    },
+
+    getDockingRefItems: function(deep, containerItems) {
+        
+        var selector = deep && '*,* *',
+            
+            dockedItems = this.getDockedItems(selector, true),
+            items;
+
+        
+        dockedItems.push.apply(dockedItems, containerItems);
+
+        
+        items = this.getDockedItems(selector, false);
+        dockedItems.push.apply(dockedItems, items);
+
+        return dockedItems;
+    },
+
+    initDockingItems: function() {
+        var me = this,
+            items = me.dockedItems;
+
+        me.dockedItems = new Ext.util.AbstractMixedCollection(false, me.getComponentId);
+        if (items) {
+            me.addDocked(items);
+        }
+    },
+
+    
+    insertDocked : function(pos, items) {
+        this.addDocked(items, pos);
+    },
+
+    
+    
+    onDockedAdd : Ext.emptyFn,
+    
+    onDockedRemove : Ext.emptyFn,
+
+    
+    removeDocked : function(item, autoDestroy) {
+        var me = this,
+            layout,
+            hasLayout;
+
+        if (!me.dockedItems.contains(item)) {
+            return item;
+        }
+
+        layout = me.componentLayout;
+        hasLayout = layout && me.rendered;
+
+        if (hasLayout) {
+            layout.onRemove(item);
+        }
+
+        me.dockedItems.remove(item);
+        item.onRemoved();
+        me.onDockedRemove(item);
+
+        if (autoDestroy === true || (autoDestroy !== false && me.autoDestroy)) {
+            item.destroy();
+        } else if (hasLayout) {
+            
+            layout.afterRemove(item);
+        }
+
+        if (!me.destroying && !me.suspendLayout) {
+            me.updateLayout();
+        }
+
+        return item;
+    },
+
+    setupDockingRenderTpl: function (renderTpl) {
+        renderTpl.renderDockedItems = this.doRenderDockedItems;
+    }
+});
+
+
+Ext.define('Ext.panel.AbstractPanel', {
+
+    
+
+    extend: 'Ext.container.Container',
+
+    mixins: {
+        docking: 'Ext.container.DockingContainer'
+    },
+
+    requires: ['Ext.util.MixedCollection', 'Ext.Element', 'Ext.toolbar.Toolbar'],
+
+    
+
+    
+    baseCls : Ext.baseCSSPrefix + 'panel',
+
+    
+
+    
+
+    
+
+    
+
+    
+    isPanel: true,
+
+    componentLayout: 'dock',
+
+    childEls: [
+        'body'
+    ],
+
+    renderTpl: [
+        
+        '{% this.renderDockedItems(out,values,0); %}',
+        
+        
+        
+        
+        
+        
+        
+        (Ext.isIE6 || Ext.isIE7 || Ext.isIEQuirks) ? '<div></div>' : '',
+        '<div id="{id}-body" class="{baseCls}-body<tpl if="bodyCls"> {bodyCls}</tpl>',
+            ' {baseCls}-body-{ui}<tpl if="uiCls">',
+                '<tpl for="uiCls"> {parent.baseCls}-body-{parent.ui}-{.}</tpl>',
+            '</tpl>"<tpl if="bodyStyle"> style="{bodyStyle}"</tpl>>',
+            '{%this.renderContainer(out,values);%}',
+        '</div>',
+        '{% this.renderDockedItems(out,values,1); %}'
+    ],
+
+    bodyPosProps: {
+        x: 'x',
+        y: 'y'
+    },
+
+    
+    
+
+    border: true,
+
+    
+    emptyArray: [],
+
+    initComponent : function() {
+        var me = this;
+
+        
+        
+
+        if (me.frame && me.border && me.bodyBorder === undefined) {
+            me.bodyBorder = false;
+        }
+        if (me.frame && me.border && (me.bodyBorder === false || me.bodyBorder === 0)) {
+            me.manageBodyBorders = true;
+        }
+
+        me.callParent();
+    },
+
+    beforeDestroy: function(){
+        this.destroyDockedItems();
+        this.callParent();
+    },
+
+    
+    initItems : function() {
+        this.callParent();
+        this.initDockingItems();
+    },
+
+    
+    initRenderData: function() {
+        var me = this,
+            data = me.callParent();
+
+        me.initBodyStyles();
+        me.protoBody.writeTo(data);
+        delete me.protoBody;
+
+        return data;
+    },
+
+    
+    getComponent: function(comp) {
+        var component = this.callParent(arguments);
+        if (component === undefined && !Ext.isNumber(comp)) {
+            
+            component = this.getDockedComponent(comp);
+        }
+        return component;
+    },
+
+    getProtoBody: function () {
+        var me = this,
+            body = me.protoBody;
+
+        if (!body) {
+            me.protoBody = body = new Ext.util.ProtoElement({
+                cls: me.bodyCls,
+                style: me.bodyStyle,
+                clsProp: 'bodyCls',
+                styleProp: 'bodyStyle',
+                styleIsText: true
+            });
+        }
+
+        return body;
+    },
+
+    
+    initBodyStyles: function() {
+        var me = this,
+            body = me.getProtoBody(),
+            Element = Ext.Element;
+
+        if (me.bodyPadding !== undefined) {
+            body.setStyle('padding', Element.unitizeBox((me.bodyPadding === true) ? 5 : me.bodyPadding));
+        }
+        if (me.frame && me.bodyBorder) {
+            if (!Ext.isNumber(me.bodyBorder)) {
+                me.bodyBorder = 1;
+            }
+            body.setStyle('border-width', Element.unitizeBox(me.bodyBorder));
+        }
+    },
+
+    getCollapsedDockedItems: function () {
+        var me = this;
+        return me.collapseMode == 'placeholder' ? me.emptyArray : [ me.getReExpander() ];
+    },
+
+    
+    setBodyStyle: function(style, value) {
+        var me = this,
+            body = me.rendered ? me.body : me.getProtoBody();
+
+        if (Ext.isFunction(style)) {
+            style = style();
+        }
+        if (arguments.length == 1) {
+            if (Ext.isString(style)) {
+                style = Ext.Element.parseStyles(style);     
+            }
+            body.setStyle(style);
+        } else {
+            body.setStyle(style, value);
+        }
+        return me;
+    },
+
+    
+    addBodyCls: function(cls) {
+        var me = this,
+            body = me.rendered ? me.body : me.getProtoBody();
+
+        body.addCls(cls);
+        return me;
+    },
+
+    
+    removeBodyCls: function(cls) {
+        var me = this,
+            body = me.rendered ? me.body : me.getProtoBody();
+
+        body.removeCls(cls);
+        return me;
+    },
+
+    
+    addUIClsToElement: function(cls) {
+        var me = this,
+            result = me.callParent(arguments);
+
+        me.addBodyCls([Ext.baseCSSPrefix + cls, me.baseCls + '-body-' + cls, me.baseCls + '-body-' + me.ui + '-' + cls]);
+        return result;
+    },
+
+    
+    removeUIClsFromElement: function(cls) {
+        var me = this,
+            result = me.callParent(arguments);
+
+        me.removeBodyCls([Ext.baseCSSPrefix + cls, me.baseCls + '-body-' + cls, me.baseCls + '-body-' + me.ui + '-' + cls]);
+        return result;
+    },
+
+    
+    addUIToElement: function() {
+        var me = this;
+
+        me.callParent(arguments);
+        me.addBodyCls(me.baseCls + '-body-' + me.ui);
+    },
+
+    
+    removeUIFromElement: function() {
+        var me = this;
+
+        me.callParent(arguments);
+        me.removeBodyCls(me.baseCls + '-body-' + me.ui);
+    },
+
+    
+    getTargetEl : function() {
+        return this.body;
+    },
+
+    getRefItems: function(deep) {
+        var items = this.callParent(arguments);
+
+        return this.getDockingRefItems(deep, items);
+    },
+
+    setupRenderTpl: function (renderTpl) {
+        this.callParent(arguments);
+        this.setupDockingRenderTpl(renderTpl);
+    }
+});
+
+
+Ext.define('Ext.layout.component.Body', {
+
+    
+
+    alias: ['layout.body'],
+
+    extend: 'Ext.layout.component.Auto',
+
+    
+
+    type: 'body',
+
+    beginLayout: function (ownerContext) {
+        this.callParent(arguments);
+
+        ownerContext.bodyContext = ownerContext.getEl('body');
+    },
+
+    
+    
+    
+    
+    
+    
+
+    calculateOwnerHeightFromContentHeight: function (ownerContext, contentHeight) {
+        var height = this.callParent(arguments);
+
+        if (ownerContext.targetContext != ownerContext) {
+            height += ownerContext.getPaddingInfo().height;
+        }
+
+        return height;
+    },
+
+    calculateOwnerWidthFromContentWidth: function (ownerContext, contentWidth) {
+        var width = this.callParent(arguments);
+
+        if (ownerContext.targetContext != ownerContext) {
+            width += ownerContext.getPaddingInfo().width;
+        }
+
+        return width;
+    },
+
+    measureContentWidth: function (ownerContext) {
+        return ownerContext.bodyContext.setWidth(ownerContext.bodyContext.el.dom.offsetWidth, false);
+    },
+
+    measureContentHeight: function (ownerContext) {
+        return ownerContext.bodyContext.setHeight(ownerContext.bodyContext.el.dom.offsetHeight, false);
+    },
+
+    publishInnerHeight: function (ownerContext, height) {
+        var innerHeight = height - ownerContext.getFrameInfo().height,
+            targetContext = ownerContext.targetContext;
+
+        if (targetContext != ownerContext) {
+            innerHeight -= ownerContext.getPaddingInfo().height;
+        }
+
+        
+        return ownerContext.bodyContext.setHeight(innerHeight, !ownerContext.heightModel.natural);
+    },
+
+    publishInnerWidth: function (ownerContext, width) {
+        var innerWidth = width - ownerContext.getFrameInfo().width,
+            targetContext = ownerContext.targetContext;
+
+        if (targetContext != ownerContext) {
+            innerWidth -= ownerContext.getPaddingInfo().width;
+        }
+
+        ownerContext.bodyContext.setWidth(innerWidth, !ownerContext.widthModel.natural);
+    }
+});
+
+
+Ext.define('Ext.panel.Header', {
+    extend: 'Ext.container.Container',
+    uses: ['Ext.panel.Tool', 'Ext.draw.Component', 'Ext.util.CSS', 'Ext.layout.component.Body', 'Ext.Img'],
+    alias: 'widget.header',
+
+    
+    isHeader       : true,
+    defaultType    : 'tool',
+    indicateDrag   : false,
+    weight         : -1,
+    componentLayout: 'body',
+
+    
+    titleAlign: 'left',
+
+    childEls: [
+        'body'
+    ],
+
+    renderTpl: [
+        '<div id="{id}-body" class="{baseCls}-body {bodyCls}',
+        '<tpl for="uiCls"> {parent.baseCls}-body-{parent.ui}-{.}</tpl>"',
+        '<tpl if="bodyStyle"> style="{bodyStyle}"</tpl>>',
+            '{%this.renderContainer(out,values)%}',
+        '</div>'
+    ],
+
+    headingTpl: '<span id="{id}-textEl" class="{cls}-text {cls}-text-{ui}">{title}</span>',
+
+    shrinkWrap: 3,
+
+    
+
+    
+    
+    
+
+    initComponent: function() {
+        var me = this,
+            ruleStyle,
+            rule,
+            style,
+            ui,
+            tempEl;
+            
+        me.addEvents(
+            
+            'click',
+            
+            
+            'dblclick'
+        );
+
+        me.indicateDragCls = me.baseCls + '-draggable';
+        me.title = me.title || '&#160;';
+        me.tools = me.tools || [];
+        me.items = me.items || [];
+        me.orientation = me.orientation || 'horizontal';
+        me.dock = (me.dock) ? me.dock : (me.orientation == 'horizontal') ? 'top' : 'left';
+
+        
+        
+        me.addClsWithUI([me.orientation, me.dock]);
+
+        if (me.indicateDrag) {
+            me.addCls(me.indicateDragCls);
+        }
+
+        
+        if (!Ext.isEmpty(me.iconCls) || !Ext.isEmpty(me.icon)) {
+            me.initIconCmp();
+            me.items.push(me.iconCmp);
+        }
+
+        
+        if (me.orientation == 'vertical') {
+            me.layout = {
+                type : 'vbox',
+                align: 'center'
+            };
+            me.textConfig = {
+                width: 16,
+                cls: me.baseCls + '-text',
+                type: 'text',
+                text: me.title,
+                rotate: {
+                    degrees: 90
+                }
+            };
+            ui = me.ui;
+            if (Ext.isArray(ui)) {
+                ui = ui[0];
+            }
+            ruleStyle = '.' + me.baseCls + '-text-' + ui;
+            if (Ext.scopeResetCSS) {
+                ruleStyle = '.' + Ext.baseCSSPrefix + 'reset ' + ruleStyle;
+            }
+            rule = Ext.util.CSS.getRule(ruleStyle);
+
+            
+            if (rule) {
+                style = rule.style;
+            } else {
+                style = (tempEl = Ext.resetElement.createChild({style: 'position:absolute', cls: me.baseCls + '-text-' + ui})).getStyles('fontFamily', 'fontWeight', 'fontSize', 'color');
+                tempEl.remove();
+            }
+            if (style) {
+                Ext.apply(me.textConfig, {
+                    'font-family': style.fontFamily,
+                    'font-weight': style.fontWeight,
+                    'font-size': style.fontSize,
+                    fill: style.color
+                });
+            }
+            me.titleCmp = new Ext.draw.Component({
+                width     : 16,
+                ariaRole  : 'heading',
+                focusable : false,
+                viewBox   : false,
+                flex      : 1,
+                id        : me.id + '_hd',
+                autoSize  : true,
+                items     : me.textConfig,
+                xhooks: {
+                    setSize: function (width) {
+                        
+                        this.callParent([width]);
+                    }
+                },
+                
+                
+                childEls  : [
+                    { name: 'textEl', select: '.' + me.baseCls + '-text' }
+                ]
+            });
+        } else {
+            me.layout = {
+                type : 'hbox',
+                align: 'middle'
+            };
+            me.titleCmp = new Ext.Component({
+                ariaRole  : 'heading',
+                focusable : false,
+                noWrap    : true,
+                flex      : 1,
+                id        : me.id + '_hd',
+                style     : 'text-align:' + me.titleAlign,
+                cls       : me.baseCls + '-text-container',
+                renderTpl : me.getTpl('headingTpl'),
+                renderData: {
+                    title: me.title,
+                    cls  : me.baseCls,
+                    ui   : me.ui
+                },
+                childEls  : ['textEl']
+            });
+        }
+        me.items.push(me.titleCmp);
+
+        
+        me.items = me.items.concat(me.tools);
+        me.callParent();
+        
+        me.on({
+            dblclick: me.onDblClick,
+            click: me.onClick,
+            element: 'el',
+            scope: me
+        });
+    },
+
+    initIconCmp: function() {
+        var me = this,
+            cfg = {
+                focusable: false,
+                src: Ext.BLANK_IMAGE_URL,
+                cls: [me.baseCls + '-icon', me.iconCls],
+                id: me.id + '-iconEl',
+                iconCls: me.iconCls
+            };
+            
+        if (!Ext.isEmpty(me.icon)) {
+            delete cfg.iconCls;
+            cfg.src = me.icon;
+        }
+        
+        me.iconCmp = new Ext.Img(cfg);
+    },
+
+    afterRender: function() {
+        this.el.unselectable();
+        this.callParent();
+    },
+
+    
+    addUIClsToElement: function(cls) {
+        var me = this,
+            result = me.callParent(arguments),
+            classes = [me.baseCls + '-body-' + cls, me.baseCls + '-body-' + me.ui + '-' + cls],
+            array, i;
+
+        if (me.bodyCls) {
+            array = me.bodyCls.split(' ');
+
+            for (i = 0; i < classes.length; i++) {
+                if (!Ext.Array.contains(array, classes[i])) {
+                    array.push(classes[i]);
+                }
+            }
+
+            me.bodyCls = array.join(' ');
+        } else {
+            me.bodyCls = classes.join(' ');
+        }
+
+        return result;
+    },
+
+    
+    removeUIClsFromElement: function(cls) {
+        var me = this,
+            result = me.callParent(arguments),
+            classes = [me.baseCls + '-body-' + cls, me.baseCls + '-body-' + me.ui + '-' + cls],
+            array, i;
+
+        if (me.bodyCls) {
+            array = me.bodyCls.split(' ');
+
+            for (i = 0; i < classes.length; i++) {
+                Ext.Array.remove(array, classes[i]);
+            }
+
+            me.bodyCls = array.join(' ');
+        }
+
+        return result;
+    },
+
+    
+    addUIToElement: function() {
+        var me = this,
+            array, cls;
+
+        me.callParent(arguments);
+
+        cls = me.baseCls + '-body-' + me.ui;
+        if (me.rendered) {
+            if (me.bodyCls) {
+                me.body.addCls(me.bodyCls);
+            } else {
+                me.body.addCls(cls);
+            }
+        } else {
+            if (me.bodyCls) {
+                array = me.bodyCls.split(' ');
+
+                if (!Ext.Array.contains(array, cls)) {
+                    array.push(cls);
+                }
+
+                me.bodyCls = array.join(' ');
+            } else {
+                me.bodyCls = cls;
+            }
+        }
+
+        if (me.titleCmp && me.titleCmp.rendered && me.titleCmp.textEl) {
+            me.titleCmp.textEl.addCls(me.baseCls + '-text-' + me.ui);
+        }
+    },
+
+    
+    removeUIFromElement: function() {
+        var me = this,
+            array, cls;
+
+        me.callParent(arguments);
+
+        cls = me.baseCls + '-body-' + me.ui;
+        if (me.rendered) {
+            if (me.bodyCls) {
+                me.body.removeCls(me.bodyCls);
+            } else {
+                me.body.removeCls(cls);
+            }
+        } else {
+            if (me.bodyCls) {
+                array = me.bodyCls.split(' ');
+                Ext.Array.remove(array, cls);
+                me.bodyCls = array.join(' ');
+            } else {
+                me.bodyCls = cls;
+            }
+        }
+
+        if (me.titleCmp && me.titleCmp.rendered && me.titleCmp.textEl) {
+            me.titleCmp.textEl.removeCls(me.baseCls + '-text-' + me.ui);
+        }
+    },
+
+    onClick: function(e) {
+        this.fireClickEvent('click', e);
+    },
+    
+    onDblClick: function(e){
+        this.fireClickEvent('dblclick', e);
+    },
+    
+    fireClickEvent: function(type, e){
+        var toolCls = '.' + Ext.panel.Tool.prototype.baseCls;
+        if (!e.getTarget(toolCls)) {
+            this.fireEvent(type, this, e);
+        }    
+    },
+
+    getFocusEl: function() {
+        return this.el;
+    },
+
+    getTargetEl: function() {
+        return this.body || this.frameBody || this.el;
+    },
+
+    
+    setTitle: function(title) {
+        var me = this,
+            sprite,
+            surface;
+        if (me.rendered) {
+            if (me.titleCmp.rendered) {
+                if (me.titleCmp.surface) {
+                    me.title = title || '';
+                    sprite = me.titleCmp.surface.items.items[0];
+                    surface = me.titleCmp.surface;
+
+                    surface.remove(sprite);
+                    me.textConfig.type = 'text';
+                    me.textConfig.text = title;
+                    sprite = surface.add(me.textConfig);
+                    sprite.setAttributes({
+                        rotate: {
+                            degrees: 90
+                        }
+                    }, true);
+                    me.titleCmp.autoSizeSurface();
+                } else {
+                    me.title = title;
+                    me.titleCmp.textEl.update(me.title || '&#160;');
+                }
+                me.titleCmp.updateLayout();
+            } else {
+                me.titleCmp.on({
+                    render: function() {
+                        me.setTitle(title);
+                    },
+                    single: true
+                });
+            }
+        } else {
+            me.title = title;
+        }
+    },
+
+    
+    getMinWidth: function() {
+        var me = this,
+            textEl = me.titleCmp.textEl.dom,
+            result,
+            tools = me.tools,
+            l, i;
+
+        
+        textEl.style.display = 'inline';
+        result = textEl.offsetWidth;
+        textEl.style.display = '';
+
+        
+        if (tools && (l = tools.length)) {
+            for (i = 0; i < l; i++) {
+                if (tools[i].el) {
+                    result += tools[i].el.dom.offsetWidth;
+                }
+            }
+        }
+
+        
+        if (me.iconCmp) {
+            result += me.iconCmp.el.dom.offsetWidth;
+        }
+
+        
+        return result + 10;
+    },
+
+    
+    setIconCls: function(cls) {
+        var me = this,
+            isEmpty = !cls || !cls.length,
+            iconCmp = me.iconCmp;
+        
+        me.iconCls = cls;
+        if (!me.iconCmp && !isEmpty) {
+            me.initIconCmp();
+            me.insert(0, me.iconCmp);
+        } else if (iconCmp) {
+            if (isEmpty) {
+                me.iconCmp.destroy();
+                delete me.iconCmp;
+            } else {
+                iconCmp.removeCls(iconCmp.iconCls);
+                iconCmp.addCls(cls);
+                iconCmp.iconCls = cls;
+            }
+        }
+    },
+    
+    
+    setIcon: function(icon) {
+        var me = this,
+            isEmpty = !icon || !icon.length,
+            iconCmp = me.iconCmp;
+        
+        me.icon = icon;
+        if (!me.iconCmp && !isEmpty) {
+            me.initIconCmp();
+            me.insert(0, me.iconCmp);
+        } else if (iconCmp) {
+            if (isEmpty) {
+                me.iconCmp.destroy();
+                delete me.iconCmp;
+            } else {
+                iconCmp.setSrc(me.icon);
+            }
+        }
+    },
+
+    
+    addTool: function(tool) {
+        this.tools.push(this.add(tool));
+    },
+
+    
+    onAdd: function(component, index) {
+        this.callParent(arguments);
+        if (component instanceof Ext.panel.Tool) {
+            component.bindTo(this.ownerCt);
+            this.tools[component.type] = component;
+        }
+    },
+
+    
+    initRenderData: function() {
+        return Ext.applyIf(this.callParent(), {
+            bodyCls: this.bodyCls
+        });
+    }
+});
+
+
+Ext.define('Ext.fx.target.Target', {
+
+    isAnimTarget: true,
+
+    
+    constructor: function(target) {
+        this.target = target;
+        this.id = this.getId();
+    },
+    
+    getId: function() {
+        return this.target.id;
+    }
+});
+
+
+Ext.define('Ext.fx.target.Element', {
+
+    
+    
+    extend: 'Ext.fx.target.Target',
+    
+    
+
+    type: 'element',
+
+    getElVal: function(el, attr, val) {
+        if (val == undefined) {
+            if (attr === 'x') {
+                val = el.getX();
+            }
+            else if (attr === 'y') {
+                val = el.getY();
+            }
+            else if (attr === 'scrollTop') {
+                val = el.getScroll().top;
+            }
+            else if (attr === 'scrollLeft') {
+                val = el.getScroll().left;
+            }
+            else if (attr === 'height') {
+                val = el.getHeight();
+            }
+            else if (attr === 'width') {
+                val = el.getWidth();
+            }
+            else {
+                val = el.getStyle(attr);
+            }
+        }
+        return val;
+    },
+
+    getAttr: function(attr, val) {
+        var el = this.target;
+        return [[ el, this.getElVal(el, attr, val)]];
+    },
+
+    setAttr: function(targetData) {
+        var target = this.target,
+            ln = targetData.length,
+            attrs, attr, o, i, j, ln2, element, value;
+        for (i = 0; i < ln; i++) {
+            attrs = targetData[i].attrs;
+            for (attr in attrs) {
+                if (attrs.hasOwnProperty(attr)) {
+                    ln2 = attrs[attr].length;
+                    for (j = 0; j < ln2; j++) {
+                        o = attrs[attr][j];
+                        element = o[0];
+                        value = o[1];
+                        if (attr === 'x') {
+                            element.setX(value);
+                        } else if (attr === 'y') {
+                            element.setY(value);
+                        } else if (attr === 'scrollTop') {
+                            element.scrollTo('top', value);
+                        } else if (attr === 'scrollLeft') {
+                            element.scrollTo('left',value);
+                        } else if (attr === 'width') {
+                            element.setWidth(value);
+                        } else if (attr === 'height') {
+                            element.setHeight(value);
+                        } else {
+                            element.setStyle(attr, value);
+                        }
+                    }
+                }
+            }
+        }
+    }
+});
+
+
+Ext.define('Ext.fx.target.ElementCSS', {
+
+    
+
+    extend: 'Ext.fx.target.Element',
+
+    
+
+    setAttr: function(targetData, isFirstFrame) {
+        var cssArr = {
+                attrs: [],
+                duration: [],
+                easing: []
+            },
+            ln = targetData.length,
+            attributes,
+            attrs,
+            attr,
+            easing,
+            duration,
+            o,
+            i,
+            j,
+            ln2;
+        for (i = 0; i < ln; i++) {
+            attrs = targetData[i];
+            duration = attrs.duration;
+            easing = attrs.easing;
+            attrs = attrs.attrs;
+            for (attr in attrs) {
+                if (Ext.Array.indexOf(cssArr.attrs, attr) == -1) {
+                    cssArr.attrs.push(attr.replace(/[A-Z]/g, function(v) {
+                        return '-' + v.toLowerCase();
+                    }));
+                    cssArr.duration.push(duration + 'ms');
+                    cssArr.easing.push(easing);
+                }
+            }
+        }
+        attributes = cssArr.attrs.join(',');
+        duration = cssArr.duration.join(',');
+        easing = cssArr.easing.join(', ');
+        for (i = 0; i < ln; i++) {
+            attrs = targetData[i].attrs;
+            for (attr in attrs) {
+                ln2 = attrs[attr].length;
+                for (j = 0; j < ln2; j++) {
+                    o = attrs[attr][j];
+                    o[0].setStyle(Ext.supports.CSS3Prefix + 'TransitionProperty', isFirstFrame ? '' : attributes);
+                    o[0].setStyle(Ext.supports.CSS3Prefix + 'TransitionDuration', isFirstFrame ? '' : duration);
+                    o[0].setStyle(Ext.supports.CSS3Prefix + 'TransitionTimingFunction', isFirstFrame ? '' : easing);
+                    o[0].setStyle(attr, o[1]);
+
+                    
+                    if (isFirstFrame) {
+                        o = o[0].dom.offsetWidth;
+                    }
+                    else {
+                        
+                        o[0].on(Ext.supports.CSS3TransitionEnd, function() {
+                            this.setStyle(Ext.supports.CSS3Prefix + 'TransitionProperty', null);
+                            this.setStyle(Ext.supports.CSS3Prefix + 'TransitionDuration', null);
+                            this.setStyle(Ext.supports.CSS3Prefix + 'TransitionTimingFunction', null);
+                        }, o[0], { single: true });
+                    }
+                }
+            }
+        }
+    }
+});
+
+
+Ext.define('Ext.fx.target.CompositeElement', {
+
+    
+
+    extend: 'Ext.fx.target.Element',
+
+    
+
+    
+    isComposite: true,
+    
+    constructor: function(target) {
+        target.id = target.id || Ext.id(null, 'ext-composite-');
+        this.callParent([target]);
+    },
+
+    getAttr: function(attr, val) {
+        var out      = [],
+            elements = this.target.elements,
+            length   = elements.length,
+            i,
+            el;
+
+        for (i = 0; i < length; i++) {
+            el = elements[i];
+
+            if (el) {
+                el = this.target.getElement(el);
+                out.push([el, this.getElVal(el, attr, val)]);
+            }
+        }
+
+        return out;
+    }
+});
+
+
+Ext.define('Ext.fx.target.CompositeElementCSS', {
+
+    
+
+    extend: 'Ext.fx.target.CompositeElement',
+
+    requires: ['Ext.fx.target.ElementCSS'],
+
+    
+    setAttr: function() {
+        return Ext.fx.target.ElementCSS.prototype.setAttr.apply(this, arguments);
+    }
+});
+
+
+
+Ext.define('Ext.fx.target.Sprite', {
+
+    
+
+    extend: 'Ext.fx.target.Target',
+
+    
+
+    type: 'draw',
+
+    getFromPrim: function (sprite, attr) {
+        var obj;
+        switch (attr) {
+            case 'rotate':
+            case 'rotation':
+                obj = sprite.attr.rotation;
+                return {
+                    x: obj.x || 0,
+                    y: obj.y || 0,
+                    degrees: obj.degrees || 0
+                };
+            case 'scale':
+            case 'scaling':
+                obj = sprite.attr.scaling;
+                return {
+                    x: obj.x || 1,
+                    y: obj.y || 1,
+                    cx: obj.cx || 0,
+                    cy: obj.cy || 0
+                };
+            case 'translate':
+            case 'translation':
+                obj = sprite.attr.translation;
+                return {
+                    x: obj.x || 0,
+                    y: obj.y || 0
+                };
+            default:
+                return sprite.attr[attr];
+        }
+    },
+
+    getAttr: function (attr, val) {
+        return [
+            [this.target, val != undefined ? val : this.getFromPrim(this.target, attr)]
+        ];
+    },
+
+    setAttr: function (targetData) {
+        var ln = targetData.length,
+            spriteArr = [],
+            attrsConf, attr, attrArr, attrs, sprite, idx, value, i, j, x, y, ln2;
+        for (i = 0; i < ln; i++) {
+            attrsConf = targetData[i].attrs;
+            for (attr in attrsConf) {
+                attrArr = attrsConf[attr];
+                ln2 = attrArr.length;
+                for (j = 0; j < ln2; j++) {
+                    sprite = attrArr[j][0];
+                    attrs = attrArr[j][1];
+                    if (attr === 'translate' || attr === 'translation') {
+                        value = {
+                            x: attrs.x,
+                            y: attrs.y
+                        };
+                    }
+                    else if (attr === 'rotate' || attr === 'rotation') {
+                        x = attrs.x;
+                        if (isNaN(x)) {
+                            x = null;
+                        }
+                        y = attrs.y;
+                        if (isNaN(y)) {
+                            y = null;
+                        }
+                        value = {
+                            degrees: attrs.degrees,
+                            x: x,
+                            y: y
+                        };
+                    } else if (attr === 'scale' || attr === 'scaling') {
+                        x = attrs.x;
+                        if (isNaN(x)) {
+                            x = null;
+                        }
+                        y = attrs.y;
+                        if (isNaN(y)) {
+                            y = null;
+                        }
+                        value = {
+                            x: x,
+                            y: y,
+                            cx: attrs.cx,
+                            cy: attrs.cy
+                        };
+                    }
+                    else if (attr === 'width' || attr === 'height' || attr === 'x' || attr === 'y') {
+                        value = parseFloat(attrs);
+                    }
+                    else {
+                        value = attrs;
+                    }
+                    idx = Ext.Array.indexOf(spriteArr, sprite);
+                    if (idx == -1) {
+                        spriteArr.push([sprite, {}]);
+                        idx = spriteArr.length - 1;
+                    }
+                    spriteArr[idx][1][attr] = value;
+                }
+            }
+        }
+        ln = spriteArr.length;
+        for (i = 0; i < ln; i++) {
+            spriteArr[i][0].setAttributes(spriteArr[i][1]);
+        }
+        this.target.redraw();
+    }
+});
+
+
+
+Ext.define('Ext.fx.target.CompositeSprite', {
+
+    
+
+    extend: 'Ext.fx.target.Sprite',
+
+    
+
+    getAttr: function(attr, val) {
+        var out     = [],
+            sprites = [].concat(this.target.items),
+            length  = sprites.length,
+            i,
+            sprite;
+
+        for (i = 0; i < length; i++) {
+            sprite = sprites[i];
+            out.push([sprite, val != undefined ? val : this.getFromPrim(sprite, attr)]);
+        }
+
+        return out;
+    }
+});
+
+
+Ext.define('Ext.fx.target.Component', {
+
+    
+   
+    extend: 'Ext.fx.target.Target',
+    
+    
+
+    type: 'component',
+
+    
+    getPropMethod: {
+        top: function() {
+            return this.getPosition(true)[1];
+        },
+        left: function() {
+            return this.getPosition(true)[0];
+        },
+        x: function() {
+            return this.getPosition()[0];
+        },
+        y: function() {
+            return this.getPosition()[1];
+        },
+        height: function() {
+            return this.getHeight();
+        },
+        width: function() {
+            return this.getWidth();
+        },
+        opacity: function() {
+            return this.el.getStyle('opacity');
+        }
+    },
+
+    compMethod: {
+        top: 'setPosition',
+        left: 'setPosition',
+        x: 'setPagePosition',
+        y: 'setPagePosition',
+        height: 'setSize',
+        width: 'setSize',
+        opacity: 'setOpacity'
+    },
+
+    
+    getAttr: function(attr, val) {
+        return [[this.target, val !== undefined ? val : this.getPropMethod[attr].call(this.target)]];
+    },
+
+    setAttr: function(targetData, isFirstFrame, isLastFrame) {
+        var me = this,
+            target = me.target,
+            ln = targetData.length,
+            attrs, attr, o, i, j, meth, targets, left, top, w, h;
+        for (i = 0; i < ln; i++) {
+            attrs = targetData[i].attrs;
+            for (attr in attrs) {
+                targets = attrs[attr].length;
+                meth = {
+                    setPosition: {},
+                    setPagePosition: {},
+                    setSize: {},
+                    setOpacity: {}
+                };
+                for (j = 0; j < targets; j++) {
+                    o = attrs[attr][j];
+                    
+                    
+                    
+                    
+                    meth[me.compMethod[attr]].target = o[0];
+                    meth[me.compMethod[attr]][attr] = o[1];
+                }
+                if (meth.setPosition.target) {
+                    o = meth.setPosition;
+                    left = (o.left === undefined) ? undefined : parseFloat(o.left);
+                    top = (o.top === undefined) ? undefined : parseFloat(o.top);
+                    o.target.setPosition(left, top);
+                }
+                if (meth.setPagePosition.target) {
+                    o = meth.setPagePosition;
+                    o.target.setPagePosition(o.x, o.y);
+                }
+                if (meth.setSize.target) {
+                    o = meth.setSize;
+                    
+                    w = (o.width === undefined) ? o.target.getWidth() : parseFloat(o.width);
+                    h = (o.height === undefined) ? o.target.getHeight() : parseFloat(o.height);
+
+                    
+                    
+                    
+                    
+                    
+                    
+                    
+                    if (isLastFrame || me.dynamic) {
+                        o.target.setSize(w, h);
+                    } else {
+                        o.target.el.setSize(w, h);
+                    }
+                }
+                if (meth.setOpacity.target) {
+                    o = meth.setOpacity;
+                    o.target.el.setStyle('opacity', o.opacity);
+                }
+            }
+        }
+    }
+});
+
+
+
+Ext.define('Ext.fx.Queue', {
+
+    requires: ['Ext.util.HashMap'],
+
+    constructor: function() {
+        this.targets = new Ext.util.HashMap();
+        this.fxQueue = {};
+    },
+
+    
+    getFxDefaults: function(targetId) {
+        var target = this.targets.get(targetId);
+        if (target) {
+            return target.fxDefaults;
+        }
+        return {};
+    },
+
+    
+    setFxDefaults: function(targetId, obj) {
+        var target = this.targets.get(targetId);
+        if (target) {
+            target.fxDefaults = Ext.apply(target.fxDefaults || {}, obj);
+        }
+    },
+
+    
+    stopAnimation: function(targetId) {
+        var me = this,
+            queue = me.getFxQueue(targetId),
+            ln = queue.length;
+        while (ln) {
+            queue[ln - 1].end();
+            ln--;
+        }
+    },
+
+    
+    getActiveAnimation: function(targetId) {
+        var queue = this.getFxQueue(targetId);
+        return (queue && !!queue.length) ? queue[0] : false;
+    },
+
+    
+    hasFxBlock: function(targetId) {
+        var queue = this.getFxQueue(targetId);
+        return queue && queue[0] && queue[0].block;
+    },
+
+    
+    getFxQueue: function(targetId) {
+        if (!targetId) {
+            return false;
+        }
+        var me = this,
+            queue = me.fxQueue[targetId],
+            target = me.targets.get(targetId);
+
+        if (!target) {
+            return false;
+        }
+
+        if (!queue) {
+            me.fxQueue[targetId] = [];
+            
+            if (target.type != 'element') {
+                target.target.on('destroy', function() {
+                    me.fxQueue[targetId] = [];
+                });
+            }
+        }
+        return me.fxQueue[targetId];
+    },
+
+    
+    queueFx: function(anim) {
+        var me = this,
+            target = anim.target,
+            queue, ln;
+
+        if (!target) {
+            return;
+        }
+
+        queue = me.getFxQueue(target.getId());
+        ln = queue.length;
+
+        if (ln) {
+            if (anim.concurrent) {
+                anim.paused = false;
+            }
+            else {
+                queue[ln - 1].on('afteranimate', function() {
+                    anim.paused = false;
+                });
+            }
+        }
+        else {
+            anim.paused = false;
+        }
+        anim.on('afteranimate', function() {
+            Ext.Array.remove(queue, anim);
+            if (anim.remove) {
+                if (target.type == 'element') {
+                    var el = Ext.get(target.id);
+                    if (el) {
+                        el.remove();
+                    }
+                }
+            }
+        }, this);
+        queue.push(anim);
+    }
+});
+
+
+
+Ext.define('Ext.fx.Manager', {
+
+    
+
+    singleton: true,
+
+    requires: ['Ext.util.MixedCollection',
+               'Ext.fx.target.Element',
+               'Ext.fx.target.ElementCSS',
+               'Ext.fx.target.CompositeElement',
+               'Ext.fx.target.CompositeElementCSS',
+               'Ext.fx.target.Sprite',
+               'Ext.fx.target.CompositeSprite',
+               'Ext.fx.target.Component'],
+
+    mixins: {
+        queue: 'Ext.fx.Queue'
+    },
+
+    
+
+    constructor: function() {
+        this.items = new Ext.util.MixedCollection();
+        this.mixins.queue.constructor.call(this);
+
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+    },
+
+    
+    interval: 16,
+
+    
+    forceJS: true,
+
+    
+    createTarget: function(target) {
+        var me = this,
+            useCSS3 = !me.forceJS && Ext.supports.Transitions,
+            targetObj;
+
+        me.useCSS3 = useCSS3;
+
+        if (target) {
+            
+            if (target.tagName || Ext.isString(target) || target.isFly) {
+                target = Ext.get(target);
+                targetObj = new Ext.fx.target['Element' + (useCSS3 ? 'CSS' : '')](target);
+            }
+            
+            else if (target.dom) {
+                targetObj = new Ext.fx.target['Element' + (useCSS3 ? 'CSS' : '')](target);
+            }
+            
+            else if (target.isComposite) {
+                targetObj = new Ext.fx.target['CompositeElement' + (useCSS3 ? 'CSS' : '')](target);
+            }
+            
+            else if (target.isSprite) {
+                targetObj = new Ext.fx.target.Sprite(target);
+            }
+            
+            else if (target.isCompositeSprite) {
+                targetObj = new Ext.fx.target.CompositeSprite(target);
+            }
+            
+            else if (target.isComponent) {
+                targetObj = new Ext.fx.target.Component(target);
+            }
+            else if (target.isAnimTarget) {
+                return target;
+            }
+            else {
+                return null;
+            }
+            me.targets.add(targetObj);
+            return targetObj;
+        }
+        else {
+            return null;
+        }
+    },
+
+    
+    addAnim: function(anim) {
+        var items = this.items,
+            task = this.task;
+
+        
+        
+        
+        items.add(anim.id, anim);
+        
+
+        
+        if (!task && items.length) {
+            task = this.task = {
+                run: this.runner,
+                interval: this.interval,
+                scope: this
+            };
+            
+            Ext.TaskManager.start(task);
+        }
+    },
+
+    
+    removeAnim: function(anim) {
+        var me = this,
+            items = me.items,
+            task = me.task;
+                
+        items.removeAtKey(anim.id);
+        
+        
+        
+        if (task && !items.length) {
+            
+            Ext.TaskManager.stop(task);
+            delete me.task;
+        }
+    },
+
+    
+    runner: function() {
+        var me = this,
+            items = me.items.getRange(),
+            i = 0,
+            len = items.length,
+            anim;
+
+        
+        me.targetArr = {};
+
+        
+        me.timestamp = new Date();
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        for (; i < len; i++) {
+            anim = items[i];
+            
+            if (anim.isReady()) {
+                
+                me.startAnim(anim);
+            }
+        }
+        
+        for (i = 0; i < len; i++) {
+            anim = items[i];
+            
+            if (anim.isRunning()) {
+                
+                me.runAnim(anim);
+            }
+        }
+
+        
+        me.applyPendingAttrs();
+    },
+
+    
+    startAnim: function(anim) {
+        anim.start(this.timestamp);
+    },
+
+    
+    runAnim: function(anim) {
+        if (!anim) {
+            return;
+        }
+        var me = this,
+            targetId = anim.target.getId(),
+            useCSS3 = me.useCSS3 && anim.target.type == 'element',
+            elapsedTime = me.timestamp - anim.startTime,
+            lastFrame = (elapsedTime >= anim.duration),
+            target, o;
+
+        target = this.collectTargetData(anim, elapsedTime, useCSS3, lastFrame);
+        
+        
+        
+        if (useCSS3) {
+            
+            
+            
+            anim.target.setAttr(target.anims[anim.id].attributes, true);
+
+            
+            me.collectTargetData(anim, anim.duration, useCSS3, lastFrame);
+
+            
+            anim.paused = true;
+
+            target = anim.target.target;
+            
+            if (anim.target.isComposite) {
+                target = anim.target.target.last();
+            }
+
+            
+            o = {};
+            o[Ext.supports.CSS3TransitionEnd] = anim.lastFrame;
+            o.scope = anim;
+            o.single = true;
+            target.on(o);
+        }
+    },
+
+    
+    collectTargetData: function(anim, elapsedTime, useCSS3, isLastFrame) {
+        var targetId = anim.target.getId(),
+            target = this.targetArr[targetId];
+        
+        if (!target) {
+            
+            
+            
+            
+            target = this.targetArr[targetId] = {
+                id: targetId,
+                el: anim.target,
+                anims: {}
+            };
+        }
+
+        
+        
+        
+        
+        target.anims[anim.id] = {
+            id: anim.id,
+            anim: anim,
+            elapsed: elapsedTime,
+            isLastFrame: isLastFrame,
+            
+            attributes: [{
+                duration: anim.duration,
+                easing: (useCSS3 && anim.reverse) ? anim.easingFn.reverse().toCSS3() : anim.easing,
+                
+                
+                attrs: anim.runAnim(elapsedTime)
+            }]
+        };
+        
+        return target;
+    },
+    
+    
+    applyPendingAttrs: function() {
+        var targetArr = this.targetArr,
+            target, targetId, animWrap, anim, animId;
+        
+        
+        for (targetId in targetArr) {
+            if (targetArr.hasOwnProperty(targetId)) {
+                target = targetArr[targetId];
+                
+                
+                for (animId in target.anims) {
+                    if (target.anims.hasOwnProperty(animId)) {
+                        animWrap = target.anims[animId];
+                        anim = animWrap.anim;
+                        
+                        
+                        if (animWrap.attributes && anim.isRunning()) {
+                            
+                            target.el.setAttr(animWrap.attributes, false, animWrap.isLastFrame);
+                            
+                            
+                            if (animWrap.isLastFrame) {
+                                
+                                anim.lastFrame();
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+});
+
+
+Ext.define('Ext.fx.Animator', {
+
+    
+
+    mixins: {
+        observable: 'Ext.util.Observable'
+    },
+
+    requires: ['Ext.fx.Manager'],
+
+    
+
+    
+    isAnimator: true,
+
+    
+    duration: 250,
+
+    
+    delay: 0,
+
+    
+    delayStart: 0,
+
+    
+    dynamic: false,
+
+    
+    easing: 'ease',
+
+    
+    running: false,
+
+    
+    paused: false,
+
+    
+    damper: 1,
+
+    
+    iterations: 1,
+
+    
+    currentIteration: 0,
+
+    
+    keyframeStep: 0,
+
+    
+    animKeyFramesRE: /^(from|to|\d+%?)$/,
+
+    
+
+     
+    constructor: function(config) {
+        var me = this;
+        config = Ext.apply(me, config || {});
+        me.config = config;
+        me.id = Ext.id(null, 'ext-animator-');
+        me.addEvents(
+            
+            'beforeanimate',
+            
+            'keyframe',
+            
+            'afteranimate'
+        );
+        me.mixins.observable.constructor.call(me, config);
+        me.timeline = [];
+        me.createTimeline(me.keyframes);
+        if (me.target) {
+            me.applyAnimator(me.target);
+            Ext.fx.Manager.addAnim(me);
+        }
+    },
+
+    
+    sorter: function (a, b) {
+        return a.pct - b.pct;
+    },
+
+    
+    createTimeline: function(keyframes) {
+        var me = this,
+            attrs = [],
+            to = me.to || {},
+            duration = me.duration,
+            prevMs, ms, i, ln, pct, anim, nextAnim, attr;
+
+        for (pct in keyframes) {
+            if (keyframes.hasOwnProperty(pct) && me.animKeyFramesRE.test(pct)) {
+                attr = {attrs: Ext.apply(keyframes[pct], to)};
+                
+                if (pct == "from") {
+                    pct = 0;
+                }
+                else if (pct == "to") {
+                    pct = 100;
+                }
+                
+                attr.pct = parseInt(pct, 10);
+                attrs.push(attr);
+            }
+        }
+        
+        Ext.Array.sort(attrs, me.sorter);
+        
+        
+        
+        
+
+        ln = attrs.length;
+        for (i = 0; i < ln; i++) {
+            prevMs = (attrs[i - 1]) ? duration * (attrs[i - 1].pct / 100) : 0;
+            ms = duration * (attrs[i].pct / 100);
+            me.timeline.push({
+                duration: ms - prevMs,
+                attrs: attrs[i].attrs
+            });
+        }
+    },
+
+    
+    applyAnimator: function(target) {
+        var me = this,
+            anims = [],
+            timeline = me.timeline,
+            reverse = me.reverse,
+            ln = timeline.length,
+            anim, easing, damper, initial, attrs, lastAttrs, i;
+
+        if (me.fireEvent('beforeanimate', me) !== false) {
+            for (i = 0; i < ln; i++) {
+                anim = timeline[i];
+                attrs = anim.attrs;
+                easing = attrs.easing || me.easing;
+                damper = attrs.damper || me.damper;
+                delete attrs.easing;
+                delete attrs.damper;
+                anim = new Ext.fx.Anim({
+                    target: target,
+                    easing: easing,
+                    damper: damper,
+                    duration: anim.duration,
+                    paused: true,
+                    to: attrs
+                });
+                anims.push(anim);
+            }
+            me.animations = anims;
+            me.target = anim.target;
+            for (i = 0; i < ln - 1; i++) {
+                anim = anims[i];
+                anim.nextAnim = anims[i + 1];
+                anim.on('afteranimate', function() {
+                    this.nextAnim.paused = false;
+                });
+                anim.on('afteranimate', function() {
+                    this.fireEvent('keyframe', this, ++this.keyframeStep);
+                }, me);
+            }
+            anims[ln - 1].on('afteranimate', function() {
+                this.lastFrame();
+            }, me);
+        }
+    },
+
+    
+    start: function(startTime) {
+        var me = this,
+            delay = me.delay,
+            delayStart = me.delayStart,
+            delayDelta;
+        if (delay) {
+            if (!delayStart) {
+                me.delayStart = startTime;
+                return;
+            }
+            else {
+                delayDelta = startTime - delayStart;
+                if (delayDelta < delay) {
+                    return;
+                }
+                else {
+                    
+                    startTime = new Date(delayStart.getTime() + delay);
+                }
+            }
+        }
+        if (me.fireEvent('beforeanimate', me) !== false) {
+            me.startTime = startTime;
+            me.running = true;
+            me.animations[me.keyframeStep].paused = false;
+        }
+    },
+
+    
+    lastFrame: function() {
+        var me = this,
+            iter = me.iterations,
+            iterCount = me.currentIteration;
+
+        iterCount++;
+        if (iterCount < iter) {
+            me.startTime = new Date();
+            me.currentIteration = iterCount;
+            me.keyframeStep = 0;
+            me.applyAnimator(me.target);
+            me.animations[me.keyframeStep].paused = false;
+        }
+        else {
+            me.currentIteration = 0;
+            me.end();
+        }
+    },
+
+    
+    end: function() {
+        var me = this;
+        me.fireEvent('afteranimate', me, me.startTime, new Date() - me.startTime);
+    },
+    
+    isReady: function() {
+        return this.paused === false && this.running === false && this.iterations > 0;
+    },
+    
+    isRunning: function() {
+        
+        return false;
+    }
+});
+
+
+Ext.define('Ext.fx.CubicBezier', {
+
+    
+
+    singleton: true,
+
+    
+
+    cubicBezierAtTime: function(t, p1x, p1y, p2x, p2y, duration) {
+        var cx = 3 * p1x,
+            bx = 3 * (p2x - p1x) - cx,
+            ax = 1 - cx - bx,
+            cy = 3 * p1y,
+            by = 3 * (p2y - p1y) - cy,
+            ay = 1 - cy - by;
+        function sampleCurveX(t) {
+            return ((ax * t + bx) * t + cx) * t;
+        }
+        function solve(x, epsilon) {
+            var t = solveCurveX(x, epsilon);
+            return ((ay * t + by) * t + cy) * t;
+        }
+        function solveCurveX(x, epsilon) {
+            var t0, t1, t2, x2, d2, i;
+            for (t2 = x, i = 0; i < 8; i++) {
+                x2 = sampleCurveX(t2) - x;
+                if (Math.abs(x2) < epsilon) {
+                    return t2;
+                }
+                d2 = (3 * ax * t2 + 2 * bx) * t2 + cx;
+                if (Math.abs(d2) < 1e-6) {
+                    break;
+                }
+                t2 = t2 - x2 / d2;
+            }
+            t0 = 0;
+            t1 = 1;
+            t2 = x;
+            if (t2 < t0) {
+                return t0;
+            }
+            if (t2 > t1) {
+                return t1;
+            }
+            while (t0 < t1) {
+                x2 = sampleCurveX(t2);
+                if (Math.abs(x2 - x) < epsilon) {
+                    return t2;
+                }
+                if (x > x2) {
+                    t0 = t2;
+                } else {
+                    t1 = t2;
+                }
+                t2 = (t1 - t0) / 2 + t0;
+            }
+            return t2;
+        }
+        return solve(t, 1 / (200 * duration));
+    },
+
+    cubicBezier: function(x1, y1, x2, y2) {
+        var fn = function(pos) {
+            return Ext.fx.CubicBezier.cubicBezierAtTime(pos, x1, y1, x2, y2, 1);
+        };
+        fn.toCSS3 = function() {
+            return 'cubic-bezier(' + [x1, y1, x2, y2].join(',') + ')';
+        };
+        fn.reverse = function() {
+            return Ext.fx.CubicBezier.cubicBezier(1 - x2, 1 - y2, 1 - x1, 1 - y1);
+        };
+        return fn;
+    }
+});
+
+//@define Ext.fx.Easing
+
+
+Ext.ns('Ext.fx');
+
+Ext.require('Ext.fx.CubicBezier', function() {
+    var math = Math,
+        pi = math.PI,
+        pow = math.pow,
+        sin = math.sin,
+        sqrt = math.sqrt,
+        abs = math.abs,
+        backInSeed = 1.70158;
+    Ext.fx.Easing = {
+        
+        
+        
+        
+        
+        
+        
+        
+    };
+
+    Ext.apply(Ext.fx.Easing, {
+        linear: function(n) {
+            return n;
+        },
+        ease: function(n) {
+            var q = 0.07813 - n / 2,
+                alpha = -0.25,
+                Q = sqrt(0.0066 + q * q),
+                x = Q - q,
+                X = pow(abs(x), 1/3) * (x < 0 ? -1 : 1),
+                y = -Q - q,
+                Y = pow(abs(y), 1/3) * (y < 0 ? -1 : 1),
+                t = X + Y + 0.25;
+            return pow(1 - t, 2) * 3 * t * 0.1 + (1 - t) * 3 * t * t + t * t * t;
+        },
+        easeIn: function (n) {
+            return pow(n, 1.7);
+        },
+        easeOut: function (n) {
+            return pow(n, 0.48);
+        },
+        easeInOut: function(n) {
+            var q = 0.48 - n / 1.04,
+                Q = sqrt(0.1734 + q * q),
+                x = Q - q,
+                X = pow(abs(x), 1/3) * (x < 0 ? -1 : 1),
+                y = -Q - q,
+                Y = pow(abs(y), 1/3) * (y < 0 ? -1 : 1),
+                t = X + Y + 0.5;
+            return (1 - t) * 3 * t * t + t * t * t;
+        },
+        backIn: function (n) {
+            return n * n * ((backInSeed + 1) * n - backInSeed);
+        },
+        backOut: function (n) {
+            n = n - 1;
+            return n * n * ((backInSeed + 1) * n + backInSeed) + 1;
+        },
+        elasticIn: function (n) {
+            if (n === 0 || n === 1) {
+                return n;
+            }
+            var p = 0.3,
+                s = p / 4;
+            return pow(2, -10 * n) * sin((n - s) * (2 * pi) / p) + 1;
+        },
+        elasticOut: function (n) {
+            return 1 - Ext.fx.Easing.elasticIn(1 - n);
+        },
+        bounceIn: function (n) {
+            return 1 - Ext.fx.Easing.bounceOut(1 - n);
+        },
+        bounceOut: function (n) {
+            var s = 7.5625,
+                p = 2.75,
+                l;
+            if (n < (1 / p)) {
+                l = s * n * n;
+            } else {
+                if (n < (2 / p)) {
+                    n -= (1.5 / p);
+                    l = s * n * n + 0.75;
+                } else {
+                    if (n < (2.5 / p)) {
+                        n -= (2.25 / p);
+                        l = s * n * n + 0.9375;
+                    } else {
+                        n -= (2.625 / p);
+                        l = s * n * n + 0.984375;
+                    }
+                }
+            }
+            return l;
+        }
+    });
+    Ext.apply(Ext.fx.Easing, {
+        'back-in': Ext.fx.Easing.backIn,
+        'back-out': Ext.fx.Easing.backOut,
+        'ease-in': Ext.fx.Easing.easeIn,
+        'ease-out': Ext.fx.Easing.easeOut,
+        'elastic-in': Ext.fx.Easing.elasticIn,
+        'elastic-out': Ext.fx.Easing.elasticIn,
+        'bounce-in': Ext.fx.Easing.bounceIn,
+        'bounce-out': Ext.fx.Easing.bounceOut,
+        'ease-in-out': Ext.fx.Easing.easeInOut
+    });
+});
+
+
+Ext.define('Ext.draw.Color', {
+
+    
+
+    
+
+    colorToHexRe: /(.*?)rgb\((\d+),\s*(\d+),\s*(\d+)\)/,
+    rgbRe: /\s*rgb\s*\(\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*\)\s*/,
+    hexRe: /\s*#([0-9a-fA-F][0-9a-fA-F]?)([0-9a-fA-F][0-9a-fA-F]?)([0-9a-fA-F][0-9a-fA-F]?)\s*/,
+
+    
+    lightnessFactor: 0.2,
+
+    
+    constructor : function(red, green, blue) {
+        var me = this,
+            clamp = Ext.Number.constrain;
+        me.r = clamp(red, 0, 255);
+        me.g = clamp(green, 0, 255);
+        me.b = clamp(blue, 0, 255);
+    },
+
+    
+    getRed: function() {
+        return this.r;
+    },
+
+    
+    getGreen: function() {
+        return this.g;
+    },
+
+    
+    getBlue: function() {
+        return this.b;
+    },
+
+    
+    getRGB: function() {
+        var me = this;
+        return [me.r, me.g, me.b];
+    },
+
+    
+    getHSL: function() {
+        var me = this,
+            r = me.r / 255,
+            g = me.g / 255,
+            b = me.b / 255,
+            max = Math.max(r, g, b),
+            min = Math.min(r, g, b),
+            delta = max - min,
+            h,
+            s = 0,
+            l = 0.5 * (max + min);
+
+        
+        if (min != max) {
+            s = (l < 0.5) ? delta / (max + min) : delta / (2 - max - min);
+            if (r == max) {
+                h = 60 * (g - b) / delta;
+            } else if (g == max) {
+                h = 120 + 60 * (b - r) / delta;
+            } else {
+                h = 240 + 60 * (r - g) / delta;
+            }
+            if (h < 0) {
+                h += 360;
+            }
+            if (h >= 360) {
+                h -= 360;
+            }
+        }
+        return [h, s, l];
+    },
+
+    
+    getLighter: function(factor) {
+        var hsl = this.getHSL();
+        factor = factor || this.lightnessFactor;
+        hsl[2] = Ext.Number.constrain(hsl[2] + factor, 0, 1);
+        return this.fromHSL(hsl[0], hsl[1], hsl[2]);
+    },
+
+    
+    getDarker: function(factor) {
+        factor = factor || this.lightnessFactor;
+        return this.getLighter(-factor);
+    },
+
+    
+    toString: function() {
+        var me = this,
+            round = Math.round,
+            r = round(me.r).toString(16),
+            g = round(me.g).toString(16),
+            b = round(me.b).toString(16);
+        r = (r.length == 1) ? '0' + r : r;
+        g = (g.length == 1) ? '0' + g : g;
+        b = (b.length == 1) ? '0' + b : b;
+        return ['#', r, g, b].join('');
+    },
+
+    
+    toHex: function(color) {
+        if (Ext.isArray(color)) {
+            color = color[0];
+        }
+        if (!Ext.isString(color)) {
+            return '';
+        }
+        if (color.substr(0, 1) === '#') {
+            return color;
+        }
+        var digits = this.colorToHexRe.exec(color),
+            red,
+            green,
+            blue,
+            rgb;
+
+        if (Ext.isArray(digits)) {
+            red = parseInt(digits[2], 10);
+            green = parseInt(digits[3], 10);
+            blue = parseInt(digits[4], 10);
+            rgb = blue | (green << 8) | (red << 16);
+            return digits[1] + '#' + ("000000" + rgb.toString(16)).slice(-6);
+        }
+        else {
+            return color;
+        }
+    },
+
+    
+    fromString: function(str) {
+        var values, r, g, b,
+            parse = parseInt;
+
+        if ((str.length == 4 || str.length == 7) && str.substr(0, 1) === '#') {
+            values = str.match(this.hexRe);
+            if (values) {
+                r = parse(values[1], 16) >> 0;
+                g = parse(values[2], 16) >> 0;
+                b = parse(values[3], 16) >> 0;
+                if (str.length == 4) {
+                    r += (r * 16);
+                    g += (g * 16);
+                    b += (b * 16);
+                }
+            }
+        }
+        else {
+            values = str.match(this.rgbRe);
+            if (values) {
+                r = values[1];
+                g = values[2];
+                b = values[3];
+            }
+        }
+
+        return (typeof r == 'undefined') ? undefined : new Ext.draw.Color(r, g, b);
+    },
+
+    
+    getGrayscale: function() {
+        
+        return this.r * 0.3 + this.g * 0.59 + this.b * 0.11;
+    },
+
+    
+    fromHSL: function(h, s, l) {
+        var C, X, m, i, rgb = [],
+            abs = Math.abs,
+            floor = Math.floor;
+
+        if (s == 0 || h == null) {
+            
+            rgb = [l, l, l];
+        }
+        else {
+            
+            
+            
+            
+            h /= 60;
+            C = s * (1 - abs(2 * l - 1));
+            X = C * (1 - abs(h - 2 * floor(h / 2) - 1));
+            m = l - C / 2;
+            switch (floor(h)) {
+                case 0:
+                    rgb = [C, X, 0];
+                    break;
+                case 1:
+                    rgb = [X, C, 0];
+                    break;
+                case 2:
+                    rgb = [0, C, X];
+                    break;
+                case 3:
+                    rgb = [0, X, C];
+                    break;
+                case 4:
+                    rgb = [X, 0, C];
+                    break;
+                case 5:
+                    rgb = [C, 0, X];
+                    break;
+            }
+            rgb = [rgb[0] + m, rgb[1] + m, rgb[2] + m];
+        }
+        return new Ext.draw.Color(rgb[0] * 255, rgb[1] * 255, rgb[2] * 255);
+    }
+}, function() {
+    var prototype = this.prototype;
+
+    
+    this.addStatics({
+        fromHSL: function() {
+            return prototype.fromHSL.apply(prototype, arguments);
+        },
+        fromString: function() {
+            return prototype.fromString.apply(prototype, arguments);
+        },
+        toHex: function() {
+            return prototype.toHex.apply(prototype, arguments);
+        }
+    });
+});
+
+
+Ext.define('Ext.draw.Draw', {
+    
+
+    singleton: true,
+
+    requires: ['Ext.draw.Color'],
+
+    
+
+    pathToStringRE: /,?([achlmqrstvxz]),?/gi,
+    pathCommandRE: /([achlmqstvz])[\s,]*((-?\d*\.?\d*(?:e[-+]?\d+)?\s*,?\s*)+)/ig,
+    pathValuesRE: /(-?\d*\.?\d*(?:e[-+]?\d+)?)\s*,?\s*/ig,
+    stopsRE: /^(\d+%?)$/,
+    radian: Math.PI / 180,
+
+    availableAnimAttrs: {
+        along: "along",
+        blur: null,
+        "clip-rect": "csv",
+        cx: null,
+        cy: null,
+        fill: "color",
+        "fill-opacity": null,
+        "font-size": null,
+        height: null,
+        opacity: null,
+        path: "path",
+        r: null,
+        rotation: "csv",
+        rx: null,
+        ry: null,
+        scale: "csv",
+        stroke: "color",
+        "stroke-opacity": null,
+        "stroke-width": null,
+        translation: "csv",
+        width: null,
+        x: null,
+        y: null
+    },
+
+    is: function(o, type) {
+        type = String(type).toLowerCase();
+        return (type == "object" && o === Object(o)) ||
+            (type == "undefined" && typeof o == type) ||
+            (type == "null" && o === null) ||
+            (type == "array" && Array.isArray && Array.isArray(o)) ||
+            (Object.prototype.toString.call(o).toLowerCase().slice(8, -1)) == type;
+    },
+
+    ellipsePath: function(sprite) {
+        var attr = sprite.attr;
+        return Ext.String.format("M{0},{1}A{2},{3},0,1,1,{0},{4}A{2},{3},0,1,1,{0},{1}z", attr.x, attr.y - attr.ry, attr.rx, attr.ry, attr.y + attr.ry);
+    },
+
+    rectPath: function(sprite) {
+        var attr = sprite.attr;
+        if (attr.radius) {
+            return Ext.String.format("M{0},{1}l{2},0a{3},{3},0,0,1,{3},{3}l0,{5}a{3},{3},0,0,1,{4},{3}l{6},0a{3},{3},0,0,1,{4},{4}l0,{7}a{3},{3},0,0,1,{3},{4}z", attr.x + attr.radius, attr.y, attr.width - attr.radius * 2, attr.radius, -attr.radius, attr.height - attr.radius * 2, attr.radius * 2 - attr.width, attr.radius * 2 - attr.height);
+        }
+        else {
+            return Ext.String.format("M{0},{1}L{2},{1},{2},{3},{0},{3}z", attr.x, attr.y, attr.width + attr.x, attr.height + attr.y);
+        }
+    },
+
+    
+    path2string: function () {
+        return this.join(",").replace(Ext.draw.Draw.pathToStringRE, "$1");
+    },
+
+    
+    pathToString: function(arrayPath) {
+        return arrayPath.join(",").replace(Ext.draw.Draw.pathToStringRE, "$1");
+    },
+
+    parsePathString: function (pathString) {
+        if (!pathString) {
+            return null;
+        }
+        var paramCounts = {a: 7, c: 6, h: 1, l: 2, m: 2, q: 4, s: 4, t: 2, v: 1, z: 0},
+            data = [],
+            me = this;
+        if (me.is(pathString, "array") && me.is(pathString[0], "array")) { 
+            data = me.pathClone(pathString);
+        }
+        if (!data.length) {
+            String(pathString).replace(me.pathCommandRE, function (a, b, c) {
+                var params = [],
+                    name = b.toLowerCase();
+                c.replace(me.pathValuesRE, function (a, b) {
+                    b && params.push(+b);
+                });
+                if (name == "m" && params.length > 2) {
+                    data.push([b].concat(Ext.Array.splice(params, 0, 2)));
+                    name = "l";
+                    b = (b == "m") ? "l" : "L";
+                }
+                while (params.length >= paramCounts[name]) {
+                    data.push([b].concat(Ext.Array.splice(params, 0, paramCounts[name])));
+                    if (!paramCounts[name]) {
+                        break;
+                    }
+                }
+            });
+        }
+        data.toString = me.path2string;
+        return data;
+    },
+
+    mapPath: function (path, matrix) {
+        if (!matrix) {
+            return path;
+        }
+        var x, y, i, ii, j, jj, pathi;
+        path = this.path2curve(path);
+        for (i = 0, ii = path.length; i < ii; i++) {
+            pathi = path[i];
+            for (j = 1, jj = pathi.length; j < jj-1; j += 2) {
+                x = matrix.x(pathi[j], pathi[j + 1]);
+                y = matrix.y(pathi[j], pathi[j + 1]);
+                pathi[j] = x;
+                pathi[j + 1] = y;
+            }
+        }
+        return path;
+    },
+
+    pathClone: function(pathArray) {
+        var res = [],
+            j, jj, i, ii;
+        if (!this.is(pathArray, "array") || !this.is(pathArray && pathArray[0], "array")) { 
+            pathArray = this.parsePathString(pathArray);
+        }
+        for (i = 0, ii = pathArray.length; i < ii; i++) {
+            res[i] = [];
+            for (j = 0, jj = pathArray[i].length; j < jj; j++) {
+                res[i][j] = pathArray[i][j];
+            }
+        }
+        res.toString = this.path2string;
+        return res;
+    },
+
+    pathToAbsolute: function (pathArray) {
+        if (!this.is(pathArray, "array") || !this.is(pathArray && pathArray[0], "array")) { 
+            pathArray = this.parsePathString(pathArray);
+        }
+        var res = [],
+            x = 0,
+            y = 0,
+            mx = 0,
+            my = 0,
+            i = 0,
+            ln = pathArray.length,
+            r, pathSegment, j, ln2;
+        
+        if (ln && pathArray[0][0] == "M") {
+            x = +pathArray[0][1];
+            y = +pathArray[0][2];
+            mx = x;
+            my = y;
+            i++;
+            res[0] = ["M", x, y];
+        }
+        for (; i < ln; i++) {
+            r = res[i] = [];
+            pathSegment = pathArray[i];
+            if (pathSegment[0] != pathSegment[0].toUpperCase()) {
+                r[0] = pathSegment[0].toUpperCase();
+                switch (r[0]) {
+                    
+                    case "A":
+                        r[1] = pathSegment[1];
+                        r[2] = pathSegment[2];
+                        r[3] = pathSegment[3];
+                        r[4] = pathSegment[4];
+                        r[5] = pathSegment[5];
+                        r[6] = +(pathSegment[6] + x);
+                        r[7] = +(pathSegment[7] + y);
+                        break;
+                    
+                    case "V":
+                        r[1] = +pathSegment[1] + y;
+                        break;
+                    
+                    case "H":
+                        r[1] = +pathSegment[1] + x;
+                        break;
+                    case "M":
+                    
+                        mx = +pathSegment[1] + x;
+                        my = +pathSegment[2] + y;
+                    default:
+                        j = 1;
+                        ln2 = pathSegment.length;
+                        for (; j < ln2; j++) {
+                            r[j] = +pathSegment[j] + ((j % 2) ? x : y);
+                        }
+                }
+            }
+            else {
+                j = 0;
+                ln2 = pathSegment.length;
+                for (; j < ln2; j++) {
+                    res[i][j] = pathSegment[j];
+                }
+            }
+            switch (r[0]) {
+                
+                case "Z":
+                    x = mx;
+                    y = my;
+                    break;
+                
+                case "H":
+                    x = r[1];
+                    break;
+                
+                case "V":
+                    y = r[1];
+                    break;
+                
+                case "M":
+                    pathSegment = res[i];
+                    ln2 = pathSegment.length;
+                    mx = pathSegment[ln2 - 2];
+                    my = pathSegment[ln2 - 1];
+                default:
+                    pathSegment = res[i];
+                    ln2 = pathSegment.length;
+                    x = pathSegment[ln2 - 2];
+                    y = pathSegment[ln2 - 1];
+            }
+        }
+        res.toString = this.path2string;
+        return res;
+    },
+
+    
+    pathToRelative: function (pathArray) {
+        if (!this.is(pathArray, "array") || !this.is(pathArray && pathArray[0], "array")) {
+            pathArray = this.parsePathString(pathArray);
+        }
+        var res = [],
+            x = 0,
+            y = 0,
+            mx = 0,
+            my = 0,
+            start = 0,
+            r,
+            pa,
+            i,
+            j,
+            k,
+            len,
+            ii,
+            jj,
+            kk;
+        
+        if (pathArray[0][0] == "M") {
+            x = pathArray[0][1];
+            y = pathArray[0][2];
+            mx = x;
+            my = y;
+            start++;
+            res.push(["M", x, y]);
+        }
+        for (i = start, ii = pathArray.length; i < ii; i++) {
+            r = res[i] = [];
+            pa = pathArray[i];
+            if (pa[0] != pa[0].toLowerCase()) {
+                r[0] = pa[0].toLowerCase();
+                switch (r[0]) {
+                    case "a":
+                        r[1] = pa[1];
+                        r[2] = pa[2];
+                        r[3] = pa[3];
+                        r[4] = pa[4];
+                        r[5] = pa[5];
+                        r[6] = +(pa[6] - x).toFixed(3);
+                        r[7] = +(pa[7] - y).toFixed(3);
+                        break;
+                    case "v":
+                        r[1] = +(pa[1] - y).toFixed(3);
+                        break;
+                    case "m":
+                        mx = pa[1];
+                        my = pa[2];
+                    default:
+                        for (j = 1, jj = pa.length; j < jj; j++) {
+                            r[j] = +(pa[j] - ((j % 2) ? x : y)).toFixed(3);
+                        }
+                }
+            } else {
+                r = res[i] = [];
+                if (pa[0] == "m") {
+                    mx = pa[1] + x;
+                    my = pa[2] + y;
+                }
+                for (k = 0, kk = pa.length; k < kk; k++) {
+                    res[i][k] = pa[k];
+                }
+            }
+            len = res[i].length;
+            switch (res[i][0]) {
+                case "z":
+                    x = mx;
+                    y = my;
+                    break;
+                case "h":
+                    x += +res[i][len - 1];
+                    break;
+                case "v":
+                    y += +res[i][len - 1];
+                    break;
+                default:
+                    x += +res[i][len - 2];
+                    y += +res[i][len - 1];
+            }
+        }
+        res.toString = this.path2string;
+        return res;
+    },
+
+    
+    path2curve: function (path) {
+        var me = this,
+            points = me.pathToAbsolute(path),
+            ln = points.length,
+            attrs = {x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null},
+            i, seg, segLn, point;
+            
+        for (i = 0; i < ln; i++) {
+            points[i] = me.command2curve(points[i], attrs);
+            if (points[i].length > 7) {
+                    points[i].shift();
+                    point = points[i];
+                    while (point.length) {
+                        Ext.Array.splice(points, i++, 0, ["C"].concat(Ext.Array.splice(point, 0, 6)));
+                    }
+                    Ext.Array.erase(points, i, 1);
+                    ln = points.length;
+                    i--;
+                }
+            seg = points[i];
+            segLn = seg.length;
+            attrs.x = seg[segLn - 2];
+            attrs.y = seg[segLn - 1];
+            attrs.bx = parseFloat(seg[segLn - 4]) || attrs.x;
+            attrs.by = parseFloat(seg[segLn - 3]) || attrs.y;
+        }
+        return points;
+    },
+    
+    interpolatePaths: function (path, path2) {
+        var me = this,
+            p = me.pathToAbsolute(path),
+            p2 = me.pathToAbsolute(path2),
+            attrs = {x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null},
+            attrs2 = {x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null},
+            fixArc = function (pp, i) {
+                if (pp[i].length > 7) {
+                    pp[i].shift();
+                    var pi = pp[i];
+                    while (pi.length) {
+                        Ext.Array.splice(pp, i++, 0, ["C"].concat(Ext.Array.splice(pi, 0, 6)));
+                    }
+                    Ext.Array.erase(pp, i, 1);
+                    ii = Math.max(p.length, p2.length || 0);
+                }
+            },
+            fixM = function (path1, path2, a1, a2, i) {
+                if (path1 && path2 && path1[i][0] == "M" && path2[i][0] != "M") {
+                    Ext.Array.splice(path2, i, 0, ["M", a2.x, a2.y]);
+                    a1.bx = 0;
+                    a1.by = 0;
+                    a1.x = path1[i][1];
+                    a1.y = path1[i][2];
+                    ii = Math.max(p.length, p2.length || 0);
+                }
+            },
+            i, ii,
+            seg, seg2, seglen, seg2len;
+        for (i = 0, ii = Math.max(p.length, p2.length || 0); i < ii; i++) {
+            p[i] = me.command2curve(p[i], attrs);
+            fixArc(p, i);
+            (p2[i] = me.command2curve(p2[i], attrs2));
+            fixArc(p2, i);
+            fixM(p, p2, attrs, attrs2, i);
+            fixM(p2, p, attrs2, attrs, i);
+            seg = p[i];
+            seg2 = p2[i];
+            seglen = seg.length;
+            seg2len = seg2.length;
+            attrs.x = seg[seglen - 2];
+            attrs.y = seg[seglen - 1];
+            attrs.bx = parseFloat(seg[seglen - 4]) || attrs.x;
+            attrs.by = parseFloat(seg[seglen - 3]) || attrs.y;
+            attrs2.bx = (parseFloat(seg2[seg2len - 4]) || attrs2.x);
+            attrs2.by = (parseFloat(seg2[seg2len - 3]) || attrs2.y);
+            attrs2.x = seg2[seg2len - 2];
+            attrs2.y = seg2[seg2len - 1];
+        }
+        return [p, p2];
+    },
+    
+    
+    command2curve: function (pathCommand, d) {
+        var me = this;
+        if (!pathCommand) {
+            return ["C", d.x, d.y, d.x, d.y, d.x, d.y];
+        }
+        if (pathCommand[0] != "T" && pathCommand[0] != "Q") {
+            d.qx = d.qy = null;
+        }
+        switch (pathCommand[0]) {
+            case "M":
+                d.X = pathCommand[1];
+                d.Y = pathCommand[2];
+                break;
+            case "A":
+                pathCommand = ["C"].concat(me.arc2curve.apply(me, [d.x, d.y].concat(pathCommand.slice(1))));
+                break;
+            case "S":
+                pathCommand = ["C", d.x + (d.x - (d.bx || d.x)), d.y + (d.y - (d.by || d.y))].concat(pathCommand.slice(1));
+                break;
+            case "T":
+                d.qx = d.x + (d.x - (d.qx || d.x));
+                d.qy = d.y + (d.y - (d.qy || d.y));
+                pathCommand = ["C"].concat(me.quadratic2curve(d.x, d.y, d.qx, d.qy, pathCommand[1], pathCommand[2]));
+                break;
+            case "Q":
+                d.qx = pathCommand[1];
+                d.qy = pathCommand[2];
+                pathCommand = ["C"].concat(me.quadratic2curve(d.x, d.y, pathCommand[1], pathCommand[2], pathCommand[3], pathCommand[4]));
+                break;
+            case "L":
+                pathCommand = ["C"].concat(d.x, d.y, pathCommand[1], pathCommand[2], pathCommand[1], pathCommand[2]);
+                break;
+            case "H":
+                pathCommand = ["C"].concat(d.x, d.y, pathCommand[1], d.y, pathCommand[1], d.y);
+                break;
+            case "V":
+                pathCommand = ["C"].concat(d.x, d.y, d.x, pathCommand[1], d.x, pathCommand[1]);
+                break;
+            case "Z":
+                pathCommand = ["C"].concat(d.x, d.y, d.X, d.Y, d.X, d.Y);
+                break;
+        }
+        return pathCommand;
+    },
+
+    quadratic2curve: function (x1, y1, ax, ay, x2, y2) {
+        var _13 = 1 / 3,
+            _23 = 2 / 3;
+        return [
+                _13 * x1 + _23 * ax,
+                _13 * y1 + _23 * ay,
+                _13 * x2 + _23 * ax,
+                _13 * y2 + _23 * ay,
+                x2,
+                y2
+            ];
+    },
+    
+    rotate: function (x, y, rad) {
+        var cos = Math.cos(rad),
+            sin = Math.sin(rad),
+            X = x * cos - y * sin,
+            Y = x * sin + y * cos;
+        return {x: X, y: Y};
+    },
+
+    arc2curve: function (x1, y1, rx, ry, angle, large_arc_flag, sweep_flag, x2, y2, recursive) {
+        
+        
+        var me = this,
+            PI = Math.PI,
+            radian = me.radian,
+            _120 = PI * 120 / 180,
+            rad = radian * (+angle || 0),
+            res = [],
+            math = Math,
+            mcos = math.cos,
+            msin = math.sin,
+            msqrt = math.sqrt,
+            mabs = math.abs,
+            masin = math.asin,
+            xy, cos, sin, x, y, h, rx2, ry2, k, cx, cy, f1, f2, df, c1, s1, c2, s2,
+            t, hx, hy, m1, m2, m3, m4, newres, i, ln, f2old, x2old, y2old;
+        if (!recursive) {
+            xy = me.rotate(x1, y1, -rad);
+            x1 = xy.x;
+            y1 = xy.y;
+            xy = me.rotate(x2, y2, -rad);
+            x2 = xy.x;
+            y2 = xy.y;
+            cos = mcos(radian * angle);
+            sin = msin(radian * angle);
+            x = (x1 - x2) / 2;
+            y = (y1 - y2) / 2;
+            h = (x * x) / (rx * rx) + (y * y) / (ry * ry);
+            if (h > 1) {
+                h = msqrt(h);
+                rx = h * rx;
+                ry = h * ry;
+            }
+            rx2 = rx * rx;
+            ry2 = ry * ry;
+            k = (large_arc_flag == sweep_flag ? -1 : 1) *
+                    msqrt(mabs((rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x)));
+            cx = k * rx * y / ry + (x1 + x2) / 2;
+            cy = k * -ry * x / rx + (y1 + y2) / 2;
+            f1 = masin(((y1 - cy) / ry).toFixed(7));
+            f2 = masin(((y2 - cy) / ry).toFixed(7));
+
+            f1 = x1 < cx ? PI - f1 : f1;
+            f2 = x2 < cx ? PI - f2 : f2;
+            if (f1 < 0) {
+                f1 = PI * 2 + f1;
+            }
+            if (f2 < 0) {
+                f2 = PI * 2 + f2;
+            }
+            if (sweep_flag && f1 > f2) {
+                f1 = f1 - PI * 2;
+            }
+            if (!sweep_flag && f2 > f1) {
+                f2 = f2 - PI * 2;
+            }
+        }
+        else {
+            f1 = recursive[0];
+            f2 = recursive[1];
+            cx = recursive[2];
+            cy = recursive[3];
+        }
+        df = f2 - f1;
+        if (mabs(df) > _120) {
+            f2old = f2;
+            x2old = x2;
+            y2old = y2;
+            f2 = f1 + _120 * (sweep_flag && f2 > f1 ? 1 : -1);
+            x2 = cx + rx * mcos(f2);
+            y2 = cy + ry * msin(f2);
+            res = me.arc2curve(x2, y2, rx, ry, angle, 0, sweep_flag, x2old, y2old, [f2, f2old, cx, cy]);
+        }
+        df = f2 - f1;
+        c1 = mcos(f1);
+        s1 = msin(f1);
+        c2 = mcos(f2);
+        s2 = msin(f2);
+        t = math.tan(df / 4);
+        hx = 4 / 3 * rx * t;
+        hy = 4 / 3 * ry * t;
+        m1 = [x1, y1];
+        m2 = [x1 + hx * s1, y1 - hy * c1];
+        m3 = [x2 + hx * s2, y2 - hy * c2];
+        m4 = [x2, y2];
+        m2[0] = 2 * m1[0] - m2[0];
+        m2[1] = 2 * m1[1] - m2[1];
+        if (recursive) {
+            return [m2, m3, m4].concat(res);
+        }
+        else {
+            res = [m2, m3, m4].concat(res).join().split(",");
+            newres = [];
+            ln = res.length;
+            for (i = 0;  i < ln; i++) {
+                newres[i] = i % 2 ? me.rotate(res[i - 1], res[i], rad).y : me.rotate(res[i], res[i + 1], rad).x;
+            }
+            return newres;
+        }
+    },
+
+    
+    rotateAndTranslatePath: function (sprite) {
+        var alpha = sprite.rotation.degrees,
+            cx = sprite.rotation.x,
+            cy = sprite.rotation.y,
+            dx = sprite.translation.x,
+            dy = sprite.translation.y,
+            path,
+            i,
+            p,
+            xy,
+            j,
+            res = [];
+        if (!alpha && !dx && !dy) {
+            return this.pathToAbsolute(sprite.attr.path);
+        }
+        dx = dx || 0;
+        dy = dy || 0;
+        path = this.pathToAbsolute(sprite.attr.path);
+        for (i = path.length; i--;) {
+            p = res[i] = path[i].slice();
+            if (p[0] == "A") {
+                xy = this.rotatePoint(p[6], p[7], alpha, cx, cy);
+                p[6] = xy.x + dx;
+                p[7] = xy.y + dy;
+            } else {
+                j = 1;
+                while (p[j + 1] != null) {
+                    xy = this.rotatePoint(p[j], p[j + 1], alpha, cx, cy);
+                    p[j] = xy.x + dx;
+                    p[j + 1] = xy.y + dy;
+                    j += 2;
+                }
+            }
+        }
+        return res;
+    },
+
+    
+    rotatePoint: function (x, y, alpha, cx, cy) {
+        if (!alpha) {
+            return {
+                x: x,
+                y: y
+            };
+        }
+        cx = cx || 0;
+        cy = cy || 0;
+        x = x - cx;
+        y = y - cy;
+        alpha = alpha * this.radian;
+        var cos = Math.cos(alpha),
+            sin = Math.sin(alpha);
+        return {
+            x: x * cos - y * sin + cx,
+            y: x * sin + y * cos + cy
+        };
+    },
+
+    pathDimensions: function (path) {
+        if (!path || !(path + "")) {
+            return {x: 0, y: 0, width: 0, height: 0};
+        }
+        path = this.path2curve(path);
+        var x = 0, 
+            y = 0,
+            X = [],
+            Y = [],
+            i = 0,
+            ln = path.length,
+            p, xmin, ymin, dim;
+        for (; i < ln; i++) {
+            p = path[i];
+            if (p[0] == "M") {
+                x = p[1];
+                y = p[2];
+                X.push(x);
+                Y.push(y);
+            }
+            else {
+                dim = this.curveDim(x, y, p[1], p[2], p[3], p[4], p[5], p[6]);
+                X = X.concat(dim.min.x, dim.max.x);
+                Y = Y.concat(dim.min.y, dim.max.y);
+                x = p[5];
+                y = p[6];
+            }
+        }
+        xmin = Math.min.apply(0, X);
+        ymin = Math.min.apply(0, Y);
+        return {
+            x: xmin,
+            y: ymin,
+            path: path,
+            width: Math.max.apply(0, X) - xmin,
+            height: Math.max.apply(0, Y) - ymin
+        };
+    },
+
+    intersectInside: function(path, cp1, cp2) {
+        return (cp2[0] - cp1[0]) * (path[1] - cp1[1]) > (cp2[1] - cp1[1]) * (path[0] - cp1[0]);
+    },
+
+    intersectIntersection: function(s, e, cp1, cp2) {
+        var p = [],
+            dcx = cp1[0] - cp2[0],
+            dcy = cp1[1] - cp2[1],
+            dpx = s[0] - e[0],
+            dpy = s[1] - e[1],
+            n1 = cp1[0] * cp2[1] - cp1[1] * cp2[0],
+            n2 = s[0] * e[1] - s[1] * e[0],
+            n3 = 1 / (dcx * dpy - dcy * dpx);
+
+        p[0] = (n1 * dpx - n2 * dcx) * n3;
+        p[1] = (n1 * dpy - n2 * dcy) * n3;
+        return p;
+    },
+
+    intersect: function(subjectPolygon, clipPolygon) {
+        var me = this,
+            i = 0,
+            ln = clipPolygon.length,
+            cp1 = clipPolygon[ln - 1],
+            outputList = subjectPolygon,
+            cp2, s, e, point, ln2, inputList, j;
+        for (; i < ln; ++i) {
+            cp2 = clipPolygon[i];
+            inputList = outputList;
+            outputList = [];
+            s = inputList[inputList.length - 1];
+            j = 0;
+            ln2 = inputList.length;
+            for (; j < ln2; j++) {
+                e = inputList[j];
+                if (me.intersectInside(e, cp1, cp2)) {
+                    if (!me.intersectInside(s, cp1, cp2)) {
+                        outputList.push(me.intersectIntersection(s, e, cp1, cp2));
+                    }
+                    outputList.push(e);
+                }
+                else if (me.intersectInside(s, cp1, cp2)) {
+                    outputList.push(me.intersectIntersection(s, e, cp1, cp2));
+                }
+                s = e;
+            }
+            cp1 = cp2;
+        }
+        return outputList;
+    },
+    
+    bezier : function (a, b, c, d, x) {
+        if (x === 0) {
+            return a;
+        } 
+        else if (x === 1) {
+            return d;
+        }
+        var du = 1 - x,
+            d3 = du * du * du,
+            r = x / du;
+        return d3 * (a + r * (3 * b + r * (3 * c + d * r)));
+    },
+    
+    bezierDim : function (a, b, c, d) {
+        var points = [], r,
+            A, top, C, delta, bottom, s,
+            min, max, i;
+        
+        if (a + 3 * c == d + 3 * b) {   
+            r = a - b;
+            r /= 2 * (a - b - b + c);
+            if ( r < 1 && r > 0) {
+                points.push(r);
+            }
+        } else {
+            
+            
+            A = a - 3 * b + 3 * c - d;
+            top = 2 * (a - b - b + c);
+            C = a - b;
+            delta = top * top - 4 * A * C;
+            bottom = A + A;
+            if (delta === 0) {
+                r = top / bottom;
+                if (r < 1 && r > 0) {
+                    points.push(r);
+                }
+            } else if (delta > 0) {
+                s = Math.sqrt(delta);
+                r = (s + top) / bottom;
+                
+                if (r < 1 && r > 0) {
+                    points.push(r);
+                }
+                
+                r = (top - s) / bottom;
+                
+                if (r < 1 && r > 0) {
+                    points.push(r);
+                }
+            }
+        }
+        min = Math.min(a, d);
+        max = Math.max(a, d);
+        for (i = 0; i < points.length; i++) {
+            min = Math.min(min, this.bezier(a, b, c, d, points[i]));
+            max = Math.max(max, this.bezier(a, b, c, d, points[i]));
+        }
+        return [min, max];
+    },
+    
+    curveDim: function (p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y) {
+        var x = this.bezierDim(p1x, c1x, c2x, p2x),
+            y = this.bezierDim(p1y, c1y, c2y, p2y);
+        return {
+            min: {
+                x: x[0],
+                y: y[0]
+            },
+            max: {
+                x: x[1],
+                y: y[1]
+            }
+        };
+    },
+
+    
+    getAnchors: function (prevX, prevY, curX, curY, nextX, nextY, value) {
+        value = value || 4;
+        var M = Math,
+            PI = M.PI,
+            halfPI = PI / 2,
+            abs = M.abs,
+            sin = M.sin,
+            cos = M.cos,
+            atan = M.atan,
+            control1Length, control2Length, control1Angle, control2Angle,
+            control1X, control1Y, control2X, control2Y, alpha;
+
+        
+        
+        control1Length = (curX - prevX) / value;
+        control2Length = (nextX - curX) / value;
+
+        
+        
+        
+        
+        if ((curY >= prevY && curY >= nextY) || (curY <= prevY && curY <= nextY)) {
+            control1Angle = control2Angle = halfPI;
+        } else {
+            control1Angle = atan((curX - prevX) / abs(curY - prevY));
+            if (prevY < curY) {
+                control1Angle = PI - control1Angle;
+            }
+            control2Angle = atan((nextX - curX) / abs(curY - nextY));
+            if (nextY < curY) {
+                control2Angle = PI - control2Angle;
+            }
+        }
+
+        
+        alpha = halfPI - ((control1Angle + control2Angle) % (PI * 2)) / 2;
+        if (alpha > halfPI) {
+            alpha -= PI;
+        }
+        control1Angle += alpha;
+        control2Angle += alpha;
+
+        
+        control1X = curX - control1Length * sin(control1Angle);
+        control1Y = curY + control1Length * cos(control1Angle);
+        control2X = curX + control2Length * sin(control2Angle);
+        control2Y = curY + control2Length * cos(control2Angle);
+
+        
+        
+        
+        
+        if ((curY > prevY && control1Y < prevY) || (curY < prevY && control1Y > prevY)) {
+            control1X += abs(prevY - control1Y) * (control1X - curX) / (control1Y - curY);
+            control1Y = prevY;
+        }
+        if ((curY > nextY && control2Y < nextY) || (curY < nextY && control2Y > nextY)) {
+            control2X -= abs(nextY - control2Y) * (control2X - curX) / (control2Y - curY);
+            control2Y = nextY;
+        }
+        
+        return {
+            x1: control1X,
+            y1: control1Y,
+            x2: control2X,
+            y2: control2Y
+        };
+    },
+
+    
+    smooth: function (originalPath, value) {
+        var path = this.path2curve(originalPath),
+            newp = [path[0]],
+            x = path[0][1],
+            y = path[0][2],
+            j,
+            points,
+            i = 1,
+            ii = path.length,
+            beg = 1,
+            mx = x,
+            my = y,
+            cx = 0,
+            cy = 0,
+            pathi,
+            pathil,
+            pathim,
+            pathiml,
+            pathip,
+            pathipl,
+            begl;
+        
+        for (; i < ii; i++) {
+            pathi = path[i];
+            pathil = pathi.length;
+            pathim = path[i - 1];
+            pathiml = pathim.length;
+            pathip = path[i + 1];
+            pathipl = pathip && pathip.length;
+            if (pathi[0] == "M") {
+                mx = pathi[1];
+                my = pathi[2];
+                j = i + 1;
+                while (path[j][0] != "C") {
+                    j++;
+                }
+                cx = path[j][5];
+                cy = path[j][6];
+                newp.push(["M", mx, my]);
+                beg = newp.length;
+                x = mx;
+                y = my;
+                continue;
+            }
+            if (pathi[pathil - 2] == mx && pathi[pathil - 1] == my && (!pathip || pathip[0] == "M")) {
+                begl = newp[beg].length;
+                points = this.getAnchors(pathim[pathiml - 2], pathim[pathiml - 1], mx, my, newp[beg][begl - 2], newp[beg][begl - 1], value);
+                newp[beg][1] = points.x2;
+                newp[beg][2] = points.y2;
+            }
+            else if (!pathip || pathip[0] == "M") {
+                points = {
+                    x1: pathi[pathil - 2],
+                    y1: pathi[pathil - 1]
+                };
+            } else {
+                points = this.getAnchors(pathim[pathiml - 2], pathim[pathiml - 1], pathi[pathil - 2], pathi[pathil - 1], pathip[pathipl - 2], pathip[pathipl - 1], value);
+            }
+            newp.push(["C", x, y, points.x1, points.y1, pathi[pathil - 2], pathi[pathil - 1]]);
+            x = points.x2;
+            y = points.y2;
+        }
+        return newp;
+    },
+
+    findDotAtSegment: function (p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t) {
+        var t1 = 1 - t;
+        return {
+            x: Math.pow(t1, 3) * p1x + Math.pow(t1, 2) * 3 * t * c1x + t1 * 3 * t * t * c2x + Math.pow(t, 3) * p2x,
+            y: Math.pow(t1, 3) * p1y + Math.pow(t1, 2) * 3 * t * c1y + t1 * 3 * t * t * c2y + Math.pow(t, 3) * p2y
+        };
+    },
+
+    
+    snapEnds: function (from, to, stepsMax, prettyNumbers) {
+        if (Ext.isDate(from)) {
+            return this.snapEndsByDate(from, to, stepsMax);
+        }
+        var step = (to - from) / stepsMax,
+            level = Math.floor(Math.log(step) / Math.LN10) + 1,
+            m = Math.pow(10, level),
+            cur,
+            modulo = Math.round((step % m) * Math.pow(10, 2 - level)),
+            interval = [[0, 15], [20, 4], [30, 2], [40, 4], [50, 9], [60, 4], [70, 2], [80, 4], [100, 15]],
+            stepCount = 0,
+            value,
+            weight,
+            i,
+            topValue,
+            topWeight = 1e9,
+            ln = interval.length;
+        cur = from = Math.floor(from / m) * m;
+        
+        if(prettyNumbers){
+            for (i = 0; i < ln; i++) {
+                value = interval[i][0];
+                weight = (value - modulo) < 0 ? 1e6 : (value - modulo) / interval[i][1];
+                if (weight < topWeight) {
+                    topValue = value;
+                    topWeight = weight;
+                }
+            }
+            step = Math.floor(step * Math.pow(10, -level)) * Math.pow(10, level) + topValue * Math.pow(10, level - 2);
+            while (cur < to) {
+                cur += step;
+                stepCount++;
+            }
+            to = +cur.toFixed(10);
+        }else{
+            stepCount = stepsMax;
+        }
+        
+        return {
+            from: from,
+            to: to,
+            power: level,
+            step: step,
+            steps: stepCount
+        };
+    },
+
+    
+    snapEndsByDate: function (from, to, stepsMax, lockEnds) {
+        var selectedStep = false,
+            scales       = [
+                [Ext.Date.MILLI, [1, 2, 3, 5, 10, 20, 30, 50, 100, 200, 300, 500]],
+                [Ext.Date.SECOND, [1, 2, 3, 5, 10, 15, 30]],
+                [Ext.Date.MINUTE, [1, 2, 3, 5, 10, 20, 30]],
+                [Ext.Date.HOUR, [1, 2, 3, 4, 6, 12]],
+                [Ext.Date.DAY, [1, 2, 3, 7, 14]],
+                [Ext.Date.MONTH, [1, 2, 3, 4, 6]]
+            ],
+            sLen         = scales.length,
+            stop         = false,
+            scale, j, yearDiff, s;
+
+        
+        for (s = 0; s < sLen; s++) {
+            scale = scales[s];
+            if (!stop) {
+                for (j = 0; j < scale[1].length; j++) {
+                    if (to < Ext.Date.add(from, scale[0], scale[1][j] * stepsMax)) {
+                        selectedStep = [scale[0], scale[1][j]];
+                        stop         = true;
+                        break;
+                    }
+                }
+            }
+        }
+
+        if (!selectedStep) {
+            yearDiff = this.snapEnds(from.getFullYear(), to.getFullYear() + 1, stepsMax, lockEnds);
+            selectedStep = [Date.YEAR, Math.round(yearDiff.step)];
+        }
+        return this.snapEndsByDateAndStep(from, to, selectedStep, lockEnds);
+    },
+
+
+    
+    snapEndsByDateAndStep: function(from, to, step, lockEnds) {
+        var fromStat = [from.getFullYear(), from.getMonth(), from.getDate(),
+                from.getHours(), from.getMinutes(), from.getSeconds(), from.getMilliseconds()],
+            steps = 0, testFrom, testTo;
+        if (lockEnds) {
+            testFrom = from;
+        } else {
+            switch (step[0]) {
+                case Ext.Date.MILLI:
+                    testFrom = new Date(fromStat[0], fromStat[1], fromStat[2], fromStat[3],
+                            fromStat[4], fromStat[5], Math.floor(fromStat[6] / step[1]) * step[1]);
+                    break;
+                case Ext.Date.SECOND:
+                    testFrom = new Date(fromStat[0], fromStat[1], fromStat[2], fromStat[3],
+                            fromStat[4], Math.floor(fromStat[5] / step[1]) * step[1], 0);
+                    break;
+                case Ext.Date.MINUTE:
+                    testFrom = new Date(fromStat[0], fromStat[1], fromStat[2], fromStat[3],
+                            Math.floor(fromStat[4] / step[1]) * step[1], 0, 0);
+                    break;
+                case Ext.Date.HOUR:
+                    testFrom = new Date(fromStat[0], fromStat[1], fromStat[2],
+                            Math.floor(fromStat[3] / step[1]) * step[1], 0, 0, 0);
+                    break;
+                case Ext.Date.DAY:
+                    testFrom = new Date(fromStat[0], fromStat[1],
+                            Math.floor(fromStat[2] - 1 / step[1]) * step[1] + 1, 0, 0, 0, 0);
+                    break;
+                case Ext.Date.MONTH:
+                    testFrom = new Date(fromStat[0], Math.floor(fromStat[1] / step[1]) * step[1], 1, 0, 0, 0, 0);
+                    break;
+                default: 
+                    testFrom = new Date(Math.floor(fromStat[0] / step[1]) * step[1], 0, 1, 0, 0, 0, 0);
+                    break;
+            }
+        }
+
+        testTo = testFrom;
+        
+        while (testTo < to) {
+            testTo = Ext.Date.add(testTo, step[0], step[1]);
+            steps++;
+        }
+
+        if (lockEnds) {
+            testTo = to;
+        }
+        return {
+            from : +testFrom,
+            to : +testTo,
+            step : (testTo - testFrom) / steps,
+            steps : steps
+        };
+    },
+
+    sorter: function (a, b) {
+        return a.offset - b.offset;
+    },
+
+    rad: function(degrees) {
+        return degrees % 360 * Math.PI / 180;
+    },
+
+    degrees: function(radian) {
+        return radian * 180 / Math.PI % 360;
+    },
+
+    withinBox: function(x, y, bbox) {
+        bbox = bbox || {};
+        return (x >= bbox.x && x <= (bbox.x + bbox.width) && y >= bbox.y && y <= (bbox.y + bbox.height));
+    },
+
+    parseGradient: function(gradient) {
+        var me = this,
+            type = gradient.type || 'linear',
+            angle = gradient.angle || 0,
+            radian = me.radian,
+            stops = gradient.stops,
+            stopsArr = [],
+            stop,
+            vector,
+            max,
+            stopObj;
+
+        if (type == 'linear') {
+            vector = [0, 0, Math.cos(angle * radian), Math.sin(angle * radian)];
+            max = 1 / (Math.max(Math.abs(vector[2]), Math.abs(vector[3])) || 1);
+            vector[2] *= max;
+            vector[3] *= max;
+            if (vector[2] < 0) {
+                vector[0] = -vector[2];
+                vector[2] = 0;
+            }
+            if (vector[3] < 0) {
+                vector[1] = -vector[3];
+                vector[3] = 0;
+            }
+        }
+
+        for (stop in stops) {
+            if (stops.hasOwnProperty(stop) && me.stopsRE.test(stop)) {
+                stopObj = {
+                    offset: parseInt(stop, 10),
+                    color: Ext.draw.Color.toHex(stops[stop].color) || '#ffffff',
+                    opacity: stops[stop].opacity || 1
+                };
+                stopsArr.push(stopObj);
+            }
+        }
+        
+        Ext.Array.sort(stopsArr, me.sorter);
+        if (type == 'linear') {
+            return {
+                id: gradient.id,
+                type: type,
+                vector: vector,
+                stops: stopsArr
+            };
+        }
+        else {
+            return {
+                id: gradient.id,
+                type: type,
+                centerX: gradient.centerX,
+                centerY: gradient.centerY,
+                focalX: gradient.focalX,
+                focalY: gradient.focalY,
+                radius: gradient.radius,
+                vector: vector,
+                stops: stopsArr
+            };
+        }
+    }
+});
+
+
+Ext.define('Ext.fx.PropertyHandler', {
+
+    
+
+    requires: ['Ext.draw.Draw'],
+
+    statics: {
+        defaultHandler: {
+            pixelDefaultsRE: /width|height|top$|bottom$|left$|right$/i,
+            unitRE: /^(-?\d*\.?\d*){1}(em|ex|px|in|cm|mm|pt|pc|%)*$/,
+            scrollRE: /^scroll/i,
+
+            computeDelta: function(from, end, damper, initial, attr) {
+                damper = (typeof damper == 'number') ? damper : 1;
+                var unitRE = this.unitRE,
+                    match = unitRE.exec(from),
+                    start, units;
+                if (match) {
+                    from = match[1];
+                    units = match[2];
+                    if (!this.scrollRE.test(attr) && !units && this.pixelDefaultsRE.test(attr)) {
+                        units = 'px';
+                    }
+                }
+                from = +from || 0;
+
+                match = unitRE.exec(end);
+                if (match) {
+                    end = match[1];
+                    units = match[2] || units;
+                }
+                end = +end || 0;
+                start = (initial != null) ? initial : from;
+                return {
+                    from: from,
+                    delta: (end - start) * damper,
+                    units: units
+                };
+            },
+
+            get: function(from, end, damper, initialFrom, attr) {
+                var ln = from.length,
+                    out = [],
+                    i, initial, res, j, len;
+                for (i = 0; i < ln; i++) {
+                    if (initialFrom) {
+                        initial = initialFrom[i][1].from;
+                    }
+                    if (Ext.isArray(from[i][1]) && Ext.isArray(end)) {
+                        res = [];
+                        j = 0;
+                        len = from[i][1].length;
+                        for (; j < len; j++) {
+                            res.push(this.computeDelta(from[i][1][j], end[j], damper, initial, attr));
+                        }
+                        out.push([from[i][0], res]);
+                    }
+                    else {
+                        out.push([from[i][0], this.computeDelta(from[i][1], end, damper, initial, attr)]);
+                    }
+                }
+                return out;
+            },
+
+            set: function(values, easing) {
+                var ln = values.length,
+                    out = [],
+                    i, val, res, len, j;
+                for (i = 0; i < ln; i++) {
+                    val  = values[i][1];
+                    if (Ext.isArray(val)) {
+                        res = [];
+                        j = 0;
+                        len = val.length;
+                        for (; j < len; j++) {
+                            res.push(val[j].from + val[j].delta * easing + (val[j].units || 0));
+                        }
+                        out.push([values[i][0], res]);
+                    } else {
+                        out.push([values[i][0], val.from + val.delta * easing + (val.units || 0)]);
+                    }
+                }
+                return out;
+            }
+        },
+        stringHandler: {
+            computeDelta: function(from, end, damper, initial, attr) {
+                return {
+                    from: from,
+                    delta: end
+                };
+            },
+
+            get: function(from, end, damper, initialFrom, attr) {
+                var ln = from.length,
+                    out = [],
+                    i, initial, res, j, len;
+                for (i = 0; i < ln; i++) {
+                    out.push([from[i][0], this.computeDelta(from[i][1], end, damper, initial, attr)]);
+                }
+                return out;
+            },
+
+            set: function(values, easing) {
+                var ln = values.length,
+                    out = [],
+                    i, val, res, len, j;
+                for (i = 0; i < ln; i++) {
+                    val  = values[i][1];
+                    out.push([values[i][0], val.delta]);
+                }
+                return out;
+            }
+        },
+        color: {
+            rgbRE: /^rgb\(([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\)$/i,
+            hexRE: /^#?([0-9A-F]{2})([0-9A-F]{2})([0-9A-F]{2})$/i,
+            hex3RE: /^#?([0-9A-F]{1})([0-9A-F]{1})([0-9A-F]{1})$/i,
+
+            parseColor : function(color, damper) {
+                damper = (typeof damper == 'number') ? damper : 1;
+                var out    = false,
+                    reList = [this.hexRE, this.rgbRE, this.hex3RE],
+                    length = reList.length,
+                    match, base, re, i;
+
+                for (i = 0; i < length; i++) {
+                    re = reList[i];
+
+                    base = (i % 2 === 0) ? 16 : 10;
+                    match = re.exec(color);
+                    if (match && match.length === 4) {
+                        if (i === 2) {
+                            match[1] += match[1];
+                            match[2] += match[2];
+                            match[3] += match[3];
+                        }
+                        out = {
+                            red: parseInt(match[1], base),
+                            green: parseInt(match[2], base),
+                            blue: parseInt(match[3], base)
+                        };
+                        break;
+                    }
+                }
+
+                return out || color;
+            },
+
+            computeDelta: function(from, end, damper, initial) {
+                from = this.parseColor(from);
+                end = this.parseColor(end, damper);
+                var start = initial ? initial : from,
+                    tfrom = typeof start,
+                    tend = typeof end;
+                
+                if (tfrom == 'string' ||  tfrom == 'undefined'
+                  || tend == 'string' || tend == 'undefined') {
+                    return end || start;
+                }
+                return {
+                    from:  from,
+                    delta: {
+                        red: Math.round((end.red - start.red) * damper),
+                        green: Math.round((end.green - start.green) * damper),
+                        blue: Math.round((end.blue - start.blue) * damper)
+                    }
+                };
+            },
+
+            get: function(start, end, damper, initialFrom) {
+                var ln = start.length,
+                    out = [],
+                    i, initial;
+                for (i = 0; i < ln; i++) {
+                    if (initialFrom) {
+                        initial = initialFrom[i][1].from;
+                    }
+                    out.push([start[i][0], this.computeDelta(start[i][1], end, damper, initial)]);
+                }
+                return out;
+            },
+
+            set: function(values, easing) {
+                var ln = values.length,
+                    out = [],
+                    i, val, parsedString, from, delta;
+                for (i = 0; i < ln; i++) {
+                    val = values[i][1];
+                    if (val) {
+                        from = val.from;
+                        delta = val.delta;
+                        
+                        val = (typeof val == 'object' && 'red' in val)? 
+                                'rgb(' + val.red + ', ' + val.green + ', ' + val.blue + ')' : val;
+                        val = (typeof val == 'object' && val.length)? val[0] : val;
+                        if (typeof val == 'undefined') {
+                            return [];
+                        }
+                        parsedString = typeof val == 'string'? val :
+                            'rgb(' + [
+                                  (from.red + Math.round(delta.red * easing)) % 256,
+                                  (from.green + Math.round(delta.green * easing)) % 256,
+                                  (from.blue + Math.round(delta.blue * easing)) % 256
+                              ].join(',') + ')';
+                        out.push([
+                            values[i][0],
+                            parsedString
+                        ]);
+                    }
+                }
+                return out;
+            }
+        },
+        object: {
+            interpolate: function(prop, damper) {
+                damper = (typeof damper == 'number') ? damper : 1;
+                var out = {},
+                    p;
+                for(p in prop) {
+                    out[p] = parseFloat(prop[p]) * damper;
+                }
+                return out;
+            },
+
+            computeDelta: function(from, end, damper, initial) {
+                from = this.interpolate(from);
+                end = this.interpolate(end, damper);
+                var start = initial ? initial : from,
+                    delta = {},
+                    p;
+
+                for(p in end) {
+                    delta[p] = end[p] - start[p];
+                }
+                return {
+                    from:  from,
+                    delta: delta
+                };
+            },
+
+            get: function(start, end, damper, initialFrom) {
+                var ln = start.length,
+                    out = [],
+                    i, initial;
+                for (i = 0; i < ln; i++) {
+                    if (initialFrom) {
+                        initial = initialFrom[i][1].from;
+                    }
+                    out.push([start[i][0], this.computeDelta(start[i][1], end, damper, initial)]);
+                }
+                return out;
+            },
+
+            set: function(values, easing) {
+                var ln = values.length,
+                    out = [],
+                    outObject = {},
+                    i, from, delta, val, p;
+                for (i = 0; i < ln; i++) {
+                    val  = values[i][1];
+                    from = val.from;
+                    delta = val.delta;
+                    for (p in from) {
+                        outObject[p] = from[p] + delta[p] * easing;
+                    }
+                    out.push([
+                        values[i][0],
+                        outObject
+                    ]);
+                }
+                return out;
+            }
+        },
+
+        path: {
+            computeDelta: function(from, end, damper, initial) {
+                damper = (typeof damper == 'number') ? damper : 1;
+                var start;
+                from = +from || 0;
+                end = +end || 0;
+                start = (initial != null) ? initial : from;
+                return {
+                    from: from,
+                    delta: (end - start) * damper
+                };
+            },
+
+            forcePath: function(path) {
+                if (!Ext.isArray(path) && !Ext.isArray(path[0])) {
+                    path = Ext.draw.Draw.parsePathString(path);
+                }
+                return path;
+            },
+
+            get: function(start, end, damper, initialFrom) {
+                var endPath = this.forcePath(end),
+                    out = [],
+                    startLn = start.length,
+                    startPathLn, pointsLn, i, deltaPath, initial, j, k, path, startPath;
+                for (i = 0; i < startLn; i++) {
+                    startPath = this.forcePath(start[i][1]);
+
+                    deltaPath = Ext.draw.Draw.interpolatePaths(startPath, endPath);
+                    startPath = deltaPath[0];
+                    endPath = deltaPath[1];
+
+                    startPathLn = startPath.length;
+                    path = [];
+                    for (j = 0; j < startPathLn; j++) {
+                        deltaPath = [startPath[j][0]];
+                        pointsLn = startPath[j].length;
+                        for (k = 1; k < pointsLn; k++) {
+                            initial = initialFrom && initialFrom[0][1][j][k].from;
+                            deltaPath.push(this.computeDelta(startPath[j][k], endPath[j][k], damper, initial));
+                        }
+                        path.push(deltaPath);
+                    }
+                    out.push([start[i][0], path]);
+                }
+                return out;
+            },
+
+            set: function(values, easing) {
+                var ln = values.length,
+                    out = [],
+                    i, j, k, newPath, calcPath, deltaPath, deltaPathLn, pointsLn;
+                for (i = 0; i < ln; i++) {
+                    deltaPath = values[i][1];
+                    newPath = [];
+                    deltaPathLn = deltaPath.length;
+                    for (j = 0; j < deltaPathLn; j++) {
+                        calcPath = [deltaPath[j][0]];
+                        pointsLn = deltaPath[j].length;
+                        for (k = 1; k < pointsLn; k++) {
+                            calcPath.push(deltaPath[j][k].from + deltaPath[j][k].delta * easing);
+                        }
+                        newPath.push(calcPath.join(','));
+                    }
+                    out.push([values[i][0], newPath.join(',')]);
+                }
+                return out;
+            }
+        }
+        
+    }
+}, function() {
+    
+    var props  = [
+            'outlineColor',
+            'backgroundColor',
+            'borderColor',
+            'borderTopColor',
+            'borderRightColor',
+            'borderBottomColor',
+            'borderLeftColor',
+            'fill',
+            'stroke'
+        ],
+        length = props.length,
+        i      = 0,
+        prop;
+
+    for (; i<length; i++) {
+        prop = props[i];
+        this[prop] = this.color;
+    }
+    
+    
+    props  = ['cursor'];
+    length = props.length;
+    i      = 0;
+
+    for (; i<length; i++) {
+        prop = props[i];
+        this[prop] = this.stringHandler;
+    }
+});
+
+
+Ext.define('Ext.fx.Anim', {
+
+    
+
+    mixins: {
+        observable: 'Ext.util.Observable'
+    },
+
+    requires: ['Ext.fx.Manager', 'Ext.fx.Animator', 'Ext.fx.Easing', 'Ext.fx.CubicBezier', 'Ext.fx.PropertyHandler'],
+
+    
+
+    
+    isAnimation: true,
+
+    
+
+    
+
+    
+    duration: 250,
+
+    
+    delay: 0,
+
+    
+    delayStart: 0,
+
+    
+    dynamic: false,
+
+    
+    easing: 'ease',
+
+    
+
+    
+    damper: 1,
+
+    
+    bezierRE: /^(?:cubic-)?bezier\(([^,]+),([^,]+),([^,]+),([^\)]+)\)/,
+
+    
+    reverse: false,
+
+    
+    running: false,
+
+    
+    paused: false,
+
+    
+    iterations: 1,
+
+    
+    alternate: false,
+
+    
+    currentIteration: 0,
+
+    
+    startTime: 0,
+
+    
+
+    
+
+    
+
+    
+    
+    
+    frameCount: 0,
+
+    
+    constructor: function(config) {
+        var me = this,
+            curve;
+            
+        config = config || {};
+        
+        if (config.keyframes) {
+            return new Ext.fx.Animator(config);
+        }
+        Ext.apply(me, config);
+        if (me.from === undefined) {
+            me.from = {};
+        }
+        me.propHandlers = {};
+        me.config = config;
+        me.target = Ext.fx.Manager.createTarget(me.target);
+        me.easingFn = Ext.fx.Easing[me.easing];
+        me.target.dynamic = me.dynamic;
+
+        
+        if (!me.easingFn) {
+            me.easingFn = String(me.easing).match(me.bezierRE);
+            if (me.easingFn && me.easingFn.length == 5) {
+                curve = me.easingFn;
+                me.easingFn = Ext.fx.CubicBezier.cubicBezier(+curve[1], +curve[2], +curve[3], +curve[4]);
+            }
+        }
+        me.id = Ext.id(null, 'ext-anim-');
+        me.addEvents(
+            
+            'beforeanimate',
+             
+            'afteranimate',
+             
+            'lastframe'
+        );
+        me.mixins.observable.constructor.call(me);
+        Ext.fx.Manager.addAnim(me);
+    },
+
+    
+    setAttr: function(attr, value) {
+        return Ext.fx.Manager.items.get(this.id).setAttr(this.target, attr, value);
+    },
+
+    
+    initAttrs: function() {
+        var me = this,
+            from = me.from,
+            to = me.to,
+            initialFrom = me.initialFrom || {},
+            out = {},
+            start, end, propHandler, attr;
+
+        for (attr in to) {
+            if (to.hasOwnProperty(attr)) {
+                start = me.target.getAttr(attr, from[attr]);
+                end = to[attr];
+                
+                if (!Ext.fx.PropertyHandler[attr]) {
+                    if (Ext.isObject(end)) {
+                        propHandler = me.propHandlers[attr] = Ext.fx.PropertyHandler.object;
+                    } else {
+                        propHandler = me.propHandlers[attr] = Ext.fx.PropertyHandler.defaultHandler;
+                    }
+                }
+                
+                else {
+                    propHandler = me.propHandlers[attr] = Ext.fx.PropertyHandler[attr];
+                }
+                out[attr] = propHandler.get(start, end, me.damper, initialFrom[attr], attr);
+            }
+        }
+        me.currentAttrs = out;
+    },
+
+    
+    start: function(startTime) {
+        var me = this,
+            delay = me.delay,
+            delayStart = me.delayStart,
+            delayDelta;
+        
+        if (delay) {
+            if (!delayStart) {
+                me.delayStart = startTime;
+                return;
+            }
+            else {
+                delayDelta = startTime - delayStart;
+                if (delayDelta < delay) {
+                    return;
+                }
+                else {
+                    
+                    startTime = new Date(delayStart.getTime() + delay);
+                }
+            }
+        }
+        if (me.fireEvent('beforeanimate', me) !== false) {
+            me.startTime = startTime;
+            if (!me.paused && !me.currentAttrs) {
+                me.initAttrs();
+            }
+            me.running = true;
+            me.frameCount = 0;
+        }
+    },
+
+    
+    runAnim: function(elapsedTime) {
+        var me = this,
+            attrs = me.currentAttrs,
+            duration = me.duration,
+            easingFn = me.easingFn,
+            propHandlers = me.propHandlers,
+            ret = {},
+            easing, values, attr, lastFrame;
+
+        if (elapsedTime >= duration) {
+            elapsedTime = duration;
+            lastFrame = true;
+        }
+        if (me.reverse) {
+            elapsedTime = duration - elapsedTime;
+        }
+
+        for (attr in attrs) {
+            if (attrs.hasOwnProperty(attr)) {
+                values = attrs[attr];
+                easing = lastFrame ? 1 : easingFn(elapsedTime / duration);
+                ret[attr] = propHandlers[attr].set(values, easing);
+            }
+        }
+        me.frameCount++;
+            
+        return ret;
+    },
+
+    
+    lastFrame: function() {
+        var me = this,
+            iter = me.iterations,
+            iterCount = me.currentIteration;
+
+        iterCount++;
+        if (iterCount < iter) {
+            if (me.alternate) {
+                me.reverse = !me.reverse;
+            }
+            me.startTime = new Date();
+            me.currentIteration = iterCount;
+            
+            me.paused = false;
+        }
+        else {
+            me.currentIteration = 0;
+            me.end();
+            me.fireEvent('lastframe', me, me.startTime);
+        }
+    },
+
+    endWasCalled: 0,
+
+    
+    end: function() {
+        if (this.endWasCalled++) {
+            return;
+        }
+        var me = this;
+        me.startTime = 0;
+        me.paused = false;
+        me.running = false;
+        Ext.fx.Manager.removeAnim(me);
+        me.fireEvent('afteranimate', me, me.startTime);
+        Ext.callback(me.callback, me.scope, [me, me.startTime]);
+    },
+    
+    isReady: function() {
+        return this.paused === false && this.running === false && this.iterations > 0;
+    },
+    
+    isRunning: function() {
+        return this.paused === false && this.running === true && this.isAnimator !== true;
+    }
+});
+
+Ext.enableFx = true;
+
+
+
+
+
+Ext.define('Ext.dd.DragDrop', {
+    requires: ['Ext.dd.DragDropManager'],
+
+    
+    constructor: function(id, sGroup, config) {
+        if(id) {
+            this.init(id, sGroup, config);
+        }
+    },
+
+    
+
+    
+    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;
+    },
+
+    
+    moveOnly: false,
+
+    
+    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(Ext.isNumber(pad)){
+            pad = {left: pad, right:pad, top:pad, bottom:pad};
+        }
+        pad = pad || this.defaultPadding;
+        var b = Ext.get(this.getEl()).getBox(),
+            ce = Ext.get(constrainTo),
+            s = ce.getScroll(),
+            c,
+            cd = ce.dom,
+            xy,
+            topSpace,
+            leftSpace;
+        if(cd == document.body){
+            c = { x: s.left, y: s.top, width: Ext.Element.getViewWidth(), height: Ext.Element.getViewHeight()};
+        }else{
+            xy = ce.getXY();
+            c = {x : xy[0], y: xy[1], width: cd.clientWidth, height: cd.clientHeight};
+        }
+
+        topSpace = b.y - c.y;
+        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);
+        Ext.EventManager.on(this.id, "mousedown", this.handleMouseDown, this);
+        
+    },
+
+    
+    initTarget: function(id, sGroup, config) {
+        
+        this.config = config || {};
+
+        
+        this.DDMInstance = Ext.dd.DragDropManager;
+        
+        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(),
+            dx, dy, p;
+
+        if (!this.DDMInstance.verifyEl(el)) {
+            return;
+        }
+
+        dx = diffX || 0;
+        dy = diffY || 0;
+
+        p = Ext.Element.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 || Ext.Element.getXY( this.getEl() );
+        this.deltaSetXY = null;
+
+        this.startPageX = p[0];
+        this.startPageY = p[1];
+    },
+
+    
+    addToGroup: function(sGroup) {
+        this.groups[sGroup] = true;
+        this.DDMInstance.regDragDrop(this, sGroup);
+    },
+
+    
+    removeFromGroup: function(sGroup) {
+        if (this.groups[sGroup]) {
+            delete this.groups[sGroup];
+        }
+
+        this.DDMInstance.removeDDFromGroup(this, sGroup);
+    },
+
+    
+    setDragElId: function(id) {
+        this.dragElId = id;
+    },
+
+    
+    setHandleElId: function(id) {
+        if (typeof id !== "string") {
+            id = Ext.id(id);
+        }
+        this.handleElId = id;
+        this.DDMInstance.regHandle(this.id, id);
+    },
+
+    
+    setOuterHandleElId: function(id) {
+        if (typeof id !== "string") {
+            id = Ext.id(id);
+        }
+        Ext.EventManager.on(id, "mousedown", this.handleMouseDown, this);
+        this.setHandleElId(id);
+
+        this.hasOuterHandles = true;
+    },
+
+    
+    unreg: function() {
+        Ext.EventManager.un(this.id, "mousedown", this.handleMouseDown, this);
+        this._domRef = null;
+        this.DDMInstance._remove(this);
+    },
+
+    destroy : function(){
+        this.unreg();
+    },
+
+    
+    isLocked: function() {
+        return (this.DDMInstance.isLocked() || this.locked);
+    },
+
+    
+    handleMouseDown: function(e, oDD){
+        if (this.primaryButtonOnly && e.button != 0) {
+            return;
+        }
+
+        if (this.isLocked()) {
+            return;
+        }
+
+        this.DDMInstance.refreshCache(this.groups);
+
+        if (this.hasOuterHandles || this.DDMInstance.isOverTarget(e.getPoint(), this) )  {
+            if (this.clickValidator(e)) {
+                
+                this.setStartPosition();
+                this.b4MouseDown(e);
+                this.onMouseDown(e);
+
+                this.DDMInstance.handleMouseDown(e, this);
+
+                this.DDMInstance.stopEvent(e);
+            }
+        }
+    },
+
+    clickValidator: function(e) {
+        var target = e.getTarget();
+        return ( this.isValidHandleChild(target) &&
+                    (this.id == this.handleElId ||
+                        this.DDMInstance.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,
+            nodeName,
+            i, len;
+        
+        try {
+            nodeName = node.nodeName.toUpperCase();
+        } catch(e) {
+            nodeName = node.nodeName;
+        }
+        valid = valid && !this.invalidHandleTypes[nodeName];
+        valid = valid && !this.invalidHandleIds[node.id];
+
+        for (i=0, len=this.invalidHandleClasses.length; valid && i<len; ++i) {
+            valid = !Ext.fly(node).hasCls(this.invalidHandleClasses[i]);
+        }
+
+
+        return valid;
+
+    },
+
+    
+    setXTicks: function(iStartX, iTickSize) {
+        this.xTicks = [];
+        this.xTickSize = iTickSize;
+
+        var tickMap = {},
+            i;
+
+        for (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;
+            }
+        }
+
+        Ext.Array.sort(this.xTicks, this.DDMInstance.numericSort);
+    },
+
+    
+    setYTicks: function(iStartY, iTickSize) {
+        this.yTicks = [];
+        this.yTickSize = iTickSize;
+
+        var tickMap = {},
+            i;
+
+        for (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;
+            }
+        }
+
+        Ext.Array.sort(this.yTicks, this.DDMInstance.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,
+                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 {
+            var i, len, next, diff1, diff2;
+            for (i=0, len=tickArray.length; i<len; ++i) {
+                next = i + 1;
+                if (tickArray[next] && tickArray[next] >= val) {
+                    diff1 = val - tickArray[i];
+                    diff2 = tickArray[next] - val;
+                    return (diff2 > diff1) ? tickArray[i] : tickArray[next];
+                }
+            }
+
+            
+            
+            return tickArray[tickArray.length - 1];
+        }
+    },
+
+    
+    toString: function() {
+        return ("DragDrop " + this.id);
+    }
+
+});
+
+
+
+
+
+Ext.define('Ext.dd.DD', {
+    extend: 'Ext.dd.DragDrop',
+    requires: ['Ext.dd.DragDropManager'],
+
+    
+    constructor: function(id, sGroup, config) {
+        if (id) {
+            this.init(id, sGroup, config);
+        }
+    },
+
+    
+    scroll: true,
+
+    
+    autoOffset: function(iPageX, iPageY) {
+        var x = iPageX - this.startPageX,
+            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),
+            fly = el.dom ? el : Ext.fly(el, '_dd'),
+            elSize = fly.getSize(),
+            EL = Ext.Element,
+            vpSize,
+            aCoord,
+            newLeft,
+            newTop;
+
+        if (!this.deltaSetXY) {
+            vpSize = this.cachedViewportSize = { width: EL.getDocumentWidth(), height: EL.getDocumentHeight() };
+            aCoord = [
+                Math.max(0, Math.min(oCoord.x, vpSize.width - elSize.width)),
+                Math.max(0, Math.min(oCoord.y, vpSize.height - elSize.height))
+            ];
+            fly.setXY(aCoord);
+            newLeft = fly.getLocalX();
+            newTop  = fly.getLocalY();
+            this.deltaSetXY = [newLeft - oCoord.x, newTop - oCoord.y];
+        } else {
+            vpSize = this.cachedViewportSize;
+            fly.setLeftTop(
+                Math.max(0, Math.min(oCoord.x + this.deltaSetXY[0], vpSize.width - elSize.width)),
+                Math.max(0, Math.min(oCoord.y + this.deltaSetXY[1], vpSize.height - elSize.height))
+            );
+        }
+
+        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.Element.getXY(this.getEl());
+            this.lastPageX = aCoord[0];
+            this.lastPageY = aCoord[1];
+        }
+    },
+
+    
+    autoScroll: function(x, y, h, w) {
+
+        if (this.scroll) {
+            
+            var clientH = Ext.Element.getViewHeight(),
+                
+                clientW = Ext.Element.getViewWidth(),
+                
+                st = this.DDMInstance.getScrollTop(),
+                
+                sl = this.DDMInstance.getScrollLeft(),
+                
+                bot = h + y,
+                
+                right = w + x,
+                
+                
+                
+                toBot = (clientH + st - y - this.deltaY),
+                
+                toRight = (clientW + sl - x - this.deltaX),
+                
+                
+                thresh = 40,
+                
+                
+                
+                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,
+            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() {
+        this.callParent();
+        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.define('Ext.dd.DDProxy', {
+    extend: 'Ext.dd.DD',
+
+    statics: {
+        
+        dragElId: "ygddfdiv"
+    },
+
+    
+    constructor: function(id, sGroup, config) {
+        if (id) {
+            this.init(id, sGroup, config);
+            this.initFrame();
+        }
+    },
+
+    
+    resizeFrame: true,
+
+    
+    centerFrame: false,
+
+    
+    createFrame: function() {
+        var self = this,
+            body = document.body,
+            div,
+            s;
+
+        if (!body || !body.firstChild) {
+            setTimeout( function() { self.createFrame(); }, 50 );
+            return;
+        }
+
+        div = this.getDragEl();
+
+        if (!div) {
+            div    = document.createElement("div");
+            div.id = this.dragElId;
+            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() {
+        this.callParent();
+
+        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(),
+            dragEl = this.getDragEl(),
+            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(),
+            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(),
+            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.define('Ext.dd.StatusProxy', {
+    extend: 'Ext.Component',
+    animRepair: false,
+
+    childEls: [
+        'ghost'
+    ],
+
+    renderTpl: [
+        '<div class="' + Ext.baseCSSPrefix + 'dd-drop-icon"></div>' +
+        '<div id="{id}-ghost" class="' + Ext.baseCSSPrefix + 'dd-drag-ghost"></div>'
+    ],
+
+    
+    constructor: function(config) {
+        var me = this;
+
+        config = config || {};
+
+        Ext.apply(me, {
+            hideMode: 'visibility',
+            hidden: true,
+            floating: true,
+            id: me.id || Ext.id(),
+            cls: Ext.baseCSSPrefix + 'dd-drag-proxy ' + this.dropNotAllowed,
+            shadow: config.shadow || false,
+            renderTo: Ext.getDetachedBody()
+        });
+        me.callParent(arguments);
+        this.dropStatus = this.dropNotAllowed;
+    },
+
+    
+    dropAllowed : Ext.baseCSSPrefix + 'dd-drop-ok',
+
+    
+    dropNotAllowed : Ext.baseCSSPrefix + 'dd-drop-nodrop',
+
+    
+    setStatus : function(cssClass){
+        cssClass = cssClass || this.dropNotAllowed;
+        if (this.dropStatus != cssClass) {
+            this.el.replaceCls(this.dropStatus, cssClass);
+            this.dropStatus = cssClass;
+        }
+    },
+
+    
+    reset : function(clearGhost){
+        var me = this,
+            clsPrefix = Ext.baseCSSPrefix + 'dd-drag-proxy ';
+
+        me.el.replaceCls(clsPrefix + me.dropAllowed, clsPrefix + me.dropNotAllowed);
+        me.dropStatus = me.dropNotAllowed;
+        if (clearGhost) {
+            me.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);
+        }
+        var el = this.ghost.dom.firstChild;
+        if (el) {
+            Ext.fly(el).setStyle('float', 'none');
+        }
+    },
+
+    
+    getGhost : function(){
+        return this.ghost;
+    },
+
+    
+    hide : function(clear) {
+        this.callParent();
+        if (clear) {
+            this.reset(true);
+        }
+    },
+
+    
+    stop : function(){
+        if (this.anim && this.anim.isAnimated && this.anim.isAnimated()) {
+            this.anim.stop();
+        }
+    },
+
+    
+    sync : function(){
+        this.el.sync();
+    },
+
+    
+    repair : function(xy, callback, scope) {
+        var me = this;
+
+        me.callback = callback;
+        me.scope = scope;
+        if (xy && me.animRepair !== false) {
+            me.el.addCls(Ext.baseCSSPrefix + 'dd-drag-repair');
+            me.el.hideUnders(true);
+            me.anim = me.el.animate({
+                duration: me.repairDuration || 500,
+                easing: 'ease-out',
+                to: {
+                    x: xy[0],
+                    y: xy[1]
+                },
+                stopAnimation: true,
+                callback: me.afterRepair,
+                scope: me
+            });
+        } else {
+            me.afterRepair();
+        }
+    },
+
+    
+    afterRepair : function() {
+        var me = this;
+    
+        me.hide(true);
+        me.el.removeCls(Ext.baseCSSPrefix + 'dd-drag-repair');
+        if (typeof me.callback == "function") {
+            me.callback.call(me.scope || me);
+        }
+        delete me.callback;
+        delete me.scope;
+    }
+});
+
+
+Ext.define('Ext.dd.DragSource', {
+    extend: 'Ext.dd.DDProxy',
+    requires: [
+        'Ext.dd.StatusProxy',
+        'Ext.dd.DragDropManager'
+    ],
+
+    
+
+    
+    dropAllowed : Ext.baseCSSPrefix + 'dd-drop-ok',
+    
+    dropNotAllowed : Ext.baseCSSPrefix + 'dd-drop-nodrop',
+
+    
+    animRepair: true,
+
+    
+    repairHighlightColor: 'c3daf9',
+
+    
+    constructor: 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({
+                id: this.el.id + '-drag-status-proxy',
+                animRepair: this.animRepair
+            });
+        }
+        this.callParent([this.el.dom, this.ddGroup || this.group,
+              {dragElId : this.proxy.id, resizeFrame: false, isTarget: false, scroll: this.scroll === true}]);
+
+        this.dragging = false;
+    },
+
+    
+    getDragData : function(e){
+        return this.dragData;
+    },
+
+    
+    onDragEnter : function(e, id){
+        var target = Ext.dd.DragDropManager.getDDById(id),
+            status;
+        this.cachedTarget = target;
+        if (this.beforeDragEnter(target, e, id) !== false) {
+            if (target.isNotifyTarget) {
+                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;
+    },
+
+    
+    onDragOver: function(e, id) {
+        var target = this.cachedTarget || Ext.dd.DragDropManager.getDDById(id),
+            status;
+        if (this.beforeDragOver(target, e, id) !== false) {
+            if(target.isNotifyTarget){
+                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.DragDropManager.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.DragDropManager.getDDById(id);
+        if (this.beforeDragDrop(target, e, id) !== false) {
+            if (target.isNotifyTarget) {
+                if (target.notifyDrop(this, e, this.dragData) !== false) { 
+                    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) {
+        
+        
+        
+        if (!e) {
+            e = target;
+            target = null;
+            id = e.getTarget().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() {
+        var me = this;
+        if (Ext.enableFx) {
+            me.el.highlight(me.repairHighlightColor);
+        }
+        me.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();
+            this.callParent(arguments);
+        }
+    },
+
+    
+    onBeforeDrag: function(data, e){
+        return true;
+    },
+
+    
+    onStartDrag: Ext.emptyFn,
+
+    alignElWithMouse: function() {
+        this.proxy.ensureAttachedToBody(true);
+        return this.callParent(arguments);
+    },
+
+    
+    startDrag: function(x, y) {
+        this.proxy.reset();
+        this.proxy.hidden = false;
+        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);
+    },
+
+    destroy: function(){
+        this.callParent();
+        Ext.destroy(this.proxy);
+    }
+});
+
+
+Ext.define('Ext.panel.Proxy', {
+
+    alternateClassName: 'Ext.dd.PanelProxy',
+    
+    
+    moveOnDrag: true,
+
+    
+    constructor: function(panel, config){
+        var me = this;
+        
+        
+        me.panel = panel;
+        me.id = me.panel.id +'-ddproxy';
+        Ext.apply(me, config);
+    },
+
+    
+    insertProxy: true,
+
+    
+    setStatus: Ext.emptyFn,
+    reset: Ext.emptyFn,
+    update: Ext.emptyFn,
+    stop: Ext.emptyFn,
+    sync: Ext.emptyFn,
+
+    
+    getEl: function(){
+        return this.ghost.el;
+    },
+
+    
+    getGhost: function(){
+        return this.ghost;
+    },
+
+    
+    getProxy: function(){
+        return this.proxy;
+    },
+
+    
+    hide : function(){
+        var me = this;
+        
+        if (me.ghost) {
+            if (me.proxy) {
+                me.proxy.remove();
+                delete me.proxy;
+            }
+
+            
+            me.panel.unghost(null, me.moveOnDrag);
+            delete me.ghost;
+        }
+    },
+
+    
+    show: function(){
+        var me = this,
+            panelSize;
+            
+        if (!me.ghost) {
+            panelSize = me.panel.getSize();
+            me.panel.el.setVisibilityMode(Ext.Element.DISPLAY);
+            me.ghost = me.panel.ghost();
+            if (me.insertProxy) {
+                
+                
+                me.proxy = me.panel.el.insertSibling({cls: Ext.baseCSSPrefix + 'panel-dd-spacer'});
+                me.proxy.setSize(panelSize);
+            }
+        }
+    },
+
+    
+    repair: function(xy, callback, scope) {
+        this.hide();
+        Ext.callback(callback, scope || this);
+    },
+
+    
+    moveProxy : function(parentNode, before){
+        if (this.proxy) {
+            parentNode.insertBefore(this.proxy.dom, before);
+        }
+    }
+});
+
+
+Ext.define('Ext.panel.DD', {
+    extend: 'Ext.dd.DragSource',
+    requires: ['Ext.panel.Proxy'],
+
+    constructor : function(panel, cfg){
+        var me = this;
+        
+        me.panel = panel;
+        me.dragData = {panel: panel};
+        me.panelProxy = new Ext.panel.Proxy(panel, cfg);
+        me.proxy = me.panelProxy.proxy;
+
+        me.callParent([panel.el, cfg]);
+        me.setupEl(panel);
+    },
+    
+    setupEl: function(panel){
+        var me = this,
+            header = panel.header,
+            el = panel.body;
+            
+        if (header) {
+            me.setHandleElId(header.id);
+            el = header.el;
+        }
+        if (el) {
+            el.setStyle('cursor', 'move');
+            me.scroll = false;
+        } else {
+            
+            panel.on('boxready', me.setupEl, me, {single: true});
+        }
+    },
+
+    showFrame: Ext.emptyFn,
+    startDrag: Ext.emptyFn,
+    
+    b4StartDrag: function(x, y) {
+        this.panelProxy.show();
+    },
+    
+    b4MouseDown: function(e) {
+        var x = e.getPageX(),
+            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.panelProxy.ghost.el.dom;
+    },
+    
+    endDrag : function(e){
+        this.panelProxy.hide();
+        this.panel.saveState();
+    },
+
+    autoOffset : function(x, y) {
+        x -= this.startPageX;
+        y -= this.startPageY;
+        this.setDelta(x, y);
+    },
+    
+    
+    
+    onInvalidDrop: function(target, e, id) {
+        var me = this;
+        
+        me.beforeInvalidDrop(target, e, id);
+        if (me.cachedTarget) {
+            if(me.cachedTarget.isNotifyTarget){
+                me.cachedTarget.notifyOut(me, e, me.dragData);
+            }
+            me.cacheTarget = null;
+        }
+
+        if (me.afterInvalidDrop) {
+            
+            me.afterInvalidDrop(e, id);
+        }
+    }
+});
+
+
+Ext.define('Ext.util.Memento', (function () {
+
+    function captureOne (src, target, prop, prefix) {
+        src[prefix ? prefix + prop : prop] = target[prop];
+    }
+
+    function removeOne (src, target, prop) {
+        delete src[prop];
+    }
+
+    function restoreOne (src, target, prop, prefix) {
+        var name = prefix ? prefix + prop : prop,
+            value = src[name];
+
+        if (value || src.hasOwnProperty(name)) {
+            restoreValue(target, prop, value);
+        }
+    }
+
+    function restoreValue (target, prop, value) {
+        if (Ext.isDefined(value)) {
+            target[prop] = value;
+        } else {
+            delete target[prop];
+        }
+    }
+
+    function doMany (doOne, src, target, props, prefix) {
+        if (src) {
+            if (Ext.isArray(props)) {
+                var p, pLen = props.length;
+                for (p = 0; p < pLen; p++) {
+                    doOne(src, target, props[p], prefix);
+                }
+            } else {
+                doOne(src, target, props, prefix);
+            }
+        }
+    }
+
+    return {
+        
+        data: null,
+
+        
+        target: null,
+
+        
+        constructor: function (target, props) {
+            if (target) {
+                this.target = target;
+                if (props) {
+                    this.capture(props);
+                }
+            }
+        },
+
+        
+        capture: function (props, target, prefix) {
+            var me = this;
+            doMany(captureOne, me.data || (me.data = {}), target || me.target, props, prefix);
+        },
+
+        
+        remove: function (props) {
+            doMany(removeOne, this.data, null, props);
+        },
+
+        
+        restore: function (props, clear, target, prefix) {
+            doMany(restoreOne, this.data, target || this.target, props, prefix);
+            if (clear !== false) {
+                this.remove(props);
+            }
+        },
+
+        
+        restoreAll: function (clear, target) {
+            var me   = this,
+                t    = target || this.target,
+                data = me.data,
+                prop;
+
+            for (prop in data) {
+                if (data.hasOwnProperty(prop)) {
+                    restoreValue(t, prop, data[prop]);
+                }
+            }
+
+            if (clear !== false) {
+                delete me.data;
+            }
+        }
+    };
+}()));
+
+
+Ext.define('Ext.panel.Panel', {
+    extend: 'Ext.panel.AbstractPanel',
+    requires: [
+        'Ext.panel.Header',
+        'Ext.fx.Anim',
+        'Ext.util.KeyMap',
+        'Ext.panel.DD',
+        'Ext.XTemplate',
+        'Ext.layout.component.Dock',
+        'Ext.util.Memento'
+    ],
+    alias: 'widget.panel',
+    alternateClassName: 'Ext.Panel',
+
+    
+    collapsedCls: 'collapsed',
+
+    
+    animCollapse: Ext.enableFx,
+
+    
+    minButtonWidth: 75,
+
+    
+    collapsed: false,
+
+    
+    collapseFirst: true,
+
+    
+    hideCollapseTool: false,
+
+    
+    titleCollapse: false,
+
+    
+
+    
+
+    
+    floatable: true,
+
+    
+
+    
+    collapsible: false,
+
+    
+
+    
+    closable: false,
+
+    
+    closeAction: 'destroy',
+
+    
+
+    
+    placeholderCollapseHideMode: Ext.Element.VISIBILITY,
+
+    
+     preventHeader: false,
+
+    
+    header: undefined,
+
+    
+    headerPosition: 'top',
+
+    
+    frame: false,
+
+    
+    frameHeader: true,
+
+    
+
+    
+
+    
+    titleAlign: 'left',
+
+    
+    manageHeight: true,
+
+    
+    
+    
+
+    initComponent: function() {
+        var me = this;
+
+        me.addEvents(
+
+            
+            'beforeclose',
+            
+            
+            'close',
+
+            
+            "beforeexpand",
+
+            
+            "beforecollapse",
+
+            
+            "expand",
+
+            
+            "collapse",
+
+            
+            'titlechange',
+
+            
+            'iconchange',
+            
+            
+            'iconclschange'
+        );
+
+        if (me.collapsible) {
+        
+            this.addStateEvents(['expand', 'collapse']);
+        }
+        if (me.unstyled) {
+            me.setUI('plain');
+        }
+
+        if (me.frame) {
+            me.setUI(me.ui + '-framed');
+        }
+
+        
+        me.bridgeToolbars();
+
+        me.callParent();
+        me.collapseDirection = me.collapseDirection || me.headerPosition || Ext.Component.DIRECTION_TOP;
+
+        
+        me.hiddenOnCollapse = new Ext.dom.CompositeElement();
+
+    },
+
+    beforeDestroy: function() {
+        var me = this;
+        Ext.destroy(
+            me.placeholder,
+            me.ghostPanel,
+            me.dd
+        );
+        me.callParent();
+    },
+
+    initAria: function() {
+        this.callParent();
+        this.initHeaderAria();
+    },
+
+    getFocusEl: function() {
+        return  this.el;
+    },
+
+    initHeaderAria: function() {
+        var me = this,
+            el = me.el,
+            header = me.header;
+        if (el && header) {
+            el.dom.setAttribute('aria-labelledby', header.titleCmp.id);
+        }
+    },
+
+    
+    getHeader: function() {
+        return this.header;
+    },
+
+    
+    setTitle: function(newTitle) {
+        var me = this,
+            oldTitle = me.title,
+            header = me.header,
+            reExpander = me.reExpander,
+            placeholder = me.placeholder;
+
+        me.title = newTitle;
+
+        if (header) {
+            if (header.isHeader) {
+                header.setTitle(newTitle);
+            } else {
+                header.title = newTitle;
+            }
+        } else {
+            me.updateHeader();
+        }
+
+        if (reExpander) {
+            reExpander.setTitle(newTitle);
+        }
+
+        if (placeholder && placeholder.setTitle) {
+            placeholder.setTitle(newTitle);
+        }
+
+        me.fireEvent('titlechange', me, newTitle, oldTitle);
+    },
+
+    
+    setIconCls: function(newIconCls) {
+        var me = this,
+            oldIconCls = me.iconCls,
+            header = me.header,
+            placeholder = me.placeholder;
+
+        me.iconCls = newIconCls;
+
+        if (header) {
+            if (header.isHeader) {
+                header.setIconCls(newIconCls);
+            } else {
+                header.iconCls = newIconCls;
+            }
+        } else {
+            me.updateHeader();
+        }
+
+        if (placeholder && placeholder.setIconCls) {
+            placeholder.setIconCls(newIconCls);
+        }
+
+        me.fireEvent('iconclschange', me, newIconCls, oldIconCls);
+    },
+    
+    
+    setIcon: function(newIcon) {
+        var me = this,
+            oldIcon = me.icon,
+            header = me.header,
+            placeholder = me.placeholder;
+
+        me.icon = newIcon;
+
+        if (header) {
+            if (header.isHeader) {
+                header.setIcon(newIcon);
+            } else {
+                header.icon = newIcon;
+            }
+        } else {
+            me.updateHeader();
+        }
+
+        if (placeholder && placeholder.setIcon) {
+            placeholder.setIcon(newIcon);
+        }
+
+        me.fireEvent('iconchange', me, newIcon, oldIcon);
+    },
+
+    bridgeToolbars: function() {
+        var me = this,
+            docked = [],
+            fbar,
+            fbarDefaults,
+            minButtonWidth = me.minButtonWidth;
+
+        function initToolbar (toolbar, pos, useButtonAlign) {
+            if (Ext.isArray(toolbar)) {
+                toolbar = {
+                    xtype: 'toolbar',
+                    items: toolbar
+                };
+            }
+            else if (!toolbar.xtype) {
+                toolbar.xtype = 'toolbar';
+            }
+            toolbar.dock = pos;
+            if (pos == 'left' || pos == 'right') {
+                toolbar.vertical = true;
+            }
+
+            
+            if (useButtonAlign) {
+                toolbar.layout = Ext.applyIf(toolbar.layout || {}, {
+                    
+                    pack: { left:'start', center:'center' }[me.buttonAlign] || 'end'
+                });
+            }
+            return toolbar;
+        }
+
+        
+
+        
+
+        
+        if (me.tbar) {
+            docked.push(initToolbar(me.tbar, 'top'));
+            me.tbar = null;
+        }
+
+        
+        if (me.bbar) {
+            docked.push(initToolbar(me.bbar, 'bottom'));
+            me.bbar = null;
+        }
+
+        
+        if (me.buttons) {
+            me.fbar = me.buttons;
+            me.buttons = null;
+        }
+
+        
+        if (me.fbar) {
+            fbar = initToolbar(me.fbar, 'bottom', true); 
+            fbar.ui = 'footer';
+
+            
+            if (minButtonWidth) {
+                fbarDefaults = fbar.defaults;
+                fbar.defaults = function(config) {
+                    var defaults = fbarDefaults || {};
+                    if ((!config.xtype || config.xtype === 'button' || (config.isComponent && config.isXType('button'))) &&
+                            !('minWidth' in defaults)) {
+                        defaults = Ext.apply({minWidth: minButtonWidth}, defaults);
+                    }
+                    return defaults;
+                };
+            }
+
+            docked.push(fbar);
+            me.fbar = null;
+        }
+
+        
+        if (me.lbar) {
+            docked.push(initToolbar(me.lbar, 'left'));
+            me.lbar = null;
+        }
+
+        
+        if (me.rbar) {
+            docked.push(initToolbar(me.rbar, 'right'));
+            me.rbar = null;
+        }
+
+        if (me.dockedItems) {
+            if (!Ext.isArray(me.dockedItems)) {
+                me.dockedItems = [me.dockedItems];
+            }
+            me.dockedItems = me.dockedItems.concat(docked);
+        } else {
+            me.dockedItems = docked;
+        }
+    },
+
+    isPlaceHolderCollapse: function(){
+        return this.collapseMode == 'placeholder';
+    },
+
+    onBoxReady: function(){
+        this.callParent();
+        if (this.collapsed) {
+            this.setHiddenDocked();
+        }    
+    },
+
+    beforeRender: function() {
+        var me = this,
+            wasCollapsed;
+
+        me.callParent();
+
+        
+        
+        me.initTools();
+
+        
+        if (!(me.preventHeader || (me.header === false))) {
+            me.updateHeader();
+        }
+
+        
+        if (me.collapsed) {
+            if (me.isPlaceHolderCollapse()) {
+                me.hidden = true;
+
+                
+                
+                
+                me.placeholderCollapse();
+                wasCollapsed = me.collapsed;
+
+                
+                
+                
+                me.collapsed = false;
+            } else {
+                me.beginCollapse();
+                me.addClsWithUI(me.collapsedCls);
+            }
+        }
+
+        
+        if (wasCollapsed) {
+            me.collapsed = wasCollapsed;
+        }
+    },
+
+    
+    initTools: function() {
+        var me = this;
+
+        me.tools = me.tools ? Ext.Array.clone(me.tools) : [];
+
+        
+        
+        if (me.collapsible && !(me.hideCollapseTool || me.header === false || me.preventHeader)) {
+            me.collapseDirection = me.collapseDirection || me.headerPosition || 'top';
+            me.collapseTool = me.expandTool = Ext.widget({
+                xtype: 'tool',
+                type: (me.collapsed && !me.isPlaceHolderCollapse()) ? ('expand-' + me.getOppositeDirection(me.collapseDirection)) : ('collapse-' + me.collapseDirection),
+                handler: me.toggleCollapse,
+                scope: me
+            });
+
+            
+            if (me.collapseFirst) {
+                me.tools.unshift(me.collapseTool);
+            }
+        }
+
+        
+        me.addTools();
+
+        
+        if (me.closable) {
+            me.addClsWithUI('closable');
+            me.addTool({
+                type: 'close',
+                handler: Ext.Function.bind(me.close, me, [])
+            });
+        }
+
+        
+        if (me.collapseTool && !me.collapseFirst) {
+            me.addTool(me.collapseTool);
+        }
+    },
+
+    
+    addTools: Ext.emptyFn,
+
+    
+    close: function() {
+        if (this.fireEvent('beforeclose', this) !== false) {
+            this.doClose();
+        }
+    },
+
+    
+    doClose: function() {
+        this.fireEvent('close', this);
+        this[this.closeAction]();
+    },
+
+    
+    updateHeader: function(force) {
+        var me = this,
+            header = me.header,
+            title = me.title,
+            tools = me.tools,
+            icon = me.icon || me.iconCls,
+            vertical = me.headerPosition == 'left' || me.headerPosition == 'right';
+
+        if ((header !== false) && (force || (title || icon) || (tools && tools.length) || (me.collapsible && !me.titleCollapse))) {
+            if (header && header.isHeader) {
+                header.show();
+            } else {
+                
+                header = me.header = Ext.widget(Ext.apply({
+                    xtype       : 'header',
+                    title       : title,
+                    titleAlign  : me.titleAlign,
+                    orientation : vertical ? 'vertical' : 'horizontal',
+                    dock        : me.headerPosition || 'top',
+                    textCls     : me.headerTextCls,
+                    iconCls     : me.iconCls,
+                    icon        : me.icon,
+                    baseCls     : me.baseCls + '-header',
+                    tools       : tools,
+                    ui          : me.ui,
+                    id          : me.id + '_header',
+                    indicateDrag: me.draggable,
+                    frame       : (me.frame || me.alwaysFramed) && me.frameHeader,
+                    ignoreParentFrame : me.frame || me.overlapHeader,
+                    ignoreBorderManagement: me.frame || me.ignoreHeaderBorderManagement,
+                    listeners   : me.collapsible && me.titleCollapse ? {
+                        click: me.toggleCollapse,
+                        scope: me
+                    } : null
+                }, me.header));
+                me.addDocked(header, 0);
+
+                
+                
+                me.tools = header.tools;
+            }
+            me.initHeaderAria();
+        } else if (header) {
+            header.hide();
+        }
+    },
+
+    
+    setUI: function(ui) {
+        var me = this;
+
+        me.callParent(arguments);
+
+        if (me.header && me.header.rendered) {
+            me.header.setUI(ui);
+        }
+    },
+
+    
+    getContentTarget: function() {
+        return this.body;
+    },
+
+    getTargetEl: function() {
+        var me = this;
+        return me.body || me.protoBody || me.frameBody || me.el;
+    },
+
+    
+
+    
+    isVisible: function(deep){
+        var me = this;
+        if (me.collapsed && me.placeholder) {
+            return me.placeholder.isVisible(deep);
+        }
+        return me.callParent(arguments);
+    },
+
+    
+    onHide: function(){
+        var me = this;
+        if (me.collapsed && me.placeholder) {
+            me.placeholder.hide();
+        } else {
+            me.callParent(arguments);
+        }
+    },
+
+    
+    onShow: function(){
+        var me = this;
+        if (me.collapsed && me.placeholder) {
+            
+            me.hidden = true;
+            me.placeholder.show();
+        } else {
+            me.callParent(arguments);
+        }
+    },
+
+    onRemoved: function(destroying) {
+        var me = this;
+
+        me.callParent(arguments);
+
+        
+        
+        if (me.placeholder && !destroying) {
+            me.ownerCt.remove(me.placeholder, false);
+        }
+    },
+
+    addTool: function(tools) {
+        tools = [].concat(tools);
+
+        var me     = this,
+            header = me.header,
+            t,
+            tLen   = tools.length,
+            tool;
+
+        for (t = 0; t < tLen; t++) {
+            tool = tools[t];
+
+            me.tools.push(tool);
+
+            if (header && header.isHeader) {
+                header.addTool(tool);
+            }
+        }
+
+        me.updateHeader();
+    },
+
+    getOppositeDirection: function(d) {
+        var c = Ext.Component;
+        switch (d) {
+            case c.DIRECTION_TOP:
+                return c.DIRECTION_BOTTOM;
+            case c.DIRECTION_RIGHT:
+                return c.DIRECTION_LEFT;
+            case c.DIRECTION_BOTTOM:
+                return c.DIRECTION_TOP;
+            case c.DIRECTION_LEFT:
+                return c.DIRECTION_RIGHT;
+        }
+    },
+
+    getWidthAuthority: function() {
+        if (this.collapsed && this.collapsedHorizontal()) {
+            return 1; 
+        }
+
+        return this.callParent();
+    },
+
+    getHeightAuthority: function() {
+        if (this.collapsed && this.collapsedVertical()) {
+            return 1; 
+        }
+
+        return this.callParent();
+    },
+
+    collapsedHorizontal: function () {
+        var dir = this.getCollapsed();
+        return dir == 'left' || dir == 'right';
+    },
+
+    collapsedVertical: function () {
+        var dir = this.getCollapsed();
+        return dir == 'top' || dir == 'bottom';
+    },
+    
+    restoreDimension: function(){
+        var dir = this.collapseDirection;
+        
+        
+        return (dir === 'top' || dir === 'bottom') ? 'height' : 'width';    
+    },
+
+    
+    getCollapsed: function() {
+        var me = this;
+        
+        
+        if (me.collapsed === true) {
+            return me.collapseDirection;
+        }
+        return me.collapsed;
+    },
+
+    getState: function() {
+        var me = this,
+            state = me.callParent(),
+            memento;
+
+        state = me.addPropertyToState(state, 'collapsed');
+
+        
+        if (me.collapsed) {
+            memento = me.collapseMemento;
+            memento = memento && memento.data;
+
+            if (me.collapsedVertical()) {
+                if (state) {
+                    delete state.height;
+                }
+                if (memento) {
+                    state = me.addPropertyToState(state, 'height', memento.height);
+                }
+            } else {
+                if (state) {
+                    delete state.width;
+                }
+                if (memento) {
+                    state = me.addPropertyToState(state, 'width', memento.width);
+                }
+            }
+        }
+
+        return state;
+    },
+
+    findReExpander: function (direction) {
+        var me = this,
+            c = Ext.Component,
+            dockedItems = me.dockedItems.items,
+            dockedItemCount = dockedItems.length,
+            comp, i;
+            
+        
+        if (me.collapseMode == 'mini') {
+            return;
+        }
+
+        switch (direction) {
+            case c.DIRECTION_TOP:
+            case c.DIRECTION_BOTTOM:
+
+                
+                
+                for (i = 0; i < dockedItemCount; i++) {
+                    comp = dockedItems[i];
+                    if (!comp.hidden) {
+                        if (comp.isHeader && (!comp.dock || comp.dock == 'top' || comp.dock == 'bottom')) {
+                            return comp;
+                        }
+                    }
+                }
+                break;
+
+            case c.DIRECTION_LEFT:
+            case c.DIRECTION_RIGHT:
+
+                
+                
+                for (i = 0; i < dockedItemCount; i++) {
+                    comp = dockedItems[i];
+                    if (!comp.hidden) {
+                        if (comp.isHeader && (comp.dock == 'left' || comp.dock == 'right')) {
+                            return comp;
+                        }
+                    }
+                }
+                break;
+
+            default:
+                throw('Panel#findReExpander must be passed a valid collapseDirection');
+        }
+    },
+
+    getReExpander: function (direction) {
+        var me = this,
+            collapseDir = direction || me.collapseDirection,
+            reExpander = me.reExpander || me.findReExpander(collapseDir);
+
+        me.expandDirection = me.getOppositeDirection(collapseDir);
+
+        if (!reExpander) {
+        
+            me.reExpander = reExpander = me.createReExpander(collapseDir, {
+                dock: collapseDir,
+                cls: Ext.baseCSSPrefix + 'docked ' + me.baseCls + '-' + me.ui + '-collapsed',
+                ownerCt: me,
+                ownerLayout: me.componentLayout
+            });
+
+            me.dockedItems.insert(0, reExpander);
+        }
+        return reExpander;
+    },
+
+    createReExpander: function(direction, defaults) {
+        var me = this,
+            isLeft = direction == 'left',
+            isRight = direction == 'right',
+            isVertical = isLeft || isRight,
+            toolAtTop,
+            result = Ext.apply({
+                hideMode: 'offsets',
+                title: me.title,
+                orientation: isVertical ? 'vertical' : 'horizontal',
+                textCls: me.headerTextCls,
+                icon: me.icon,
+                iconCls: me.iconCls,
+                baseCls: me.baseCls + '-header',
+                ui: me.ui,
+                frame: me.frame && me.frameHeader,
+                ignoreParentFrame: me.frame || me.overlapHeader,
+                indicateDrag: me.draggable
+            }, defaults);
+            
+            
+            
+            if (me.collapseMode == 'mini') {
+                if (isVertical) {
+                    result.width = 1;
+                } else {
+                    result.height = 1;
+                }
+            }
+
+        
+        
+        
+        if (!me.hideCollapseTool) {
+            toolAtTop = isLeft || (isRight && me.isPlaceHolderCollapse());
+            result[toolAtTop ? 'items' : 'tools'] = [{
+                xtype: 'tool',
+                type: 'expand-' + me.getOppositeDirection(direction),
+                uiCls: ['top'],
+                handler: me.toggleCollapse,
+                scope: me
+            }];
+        }
+        result = new Ext.panel.Header(result);
+        result.addClsWithUI(me.getHeaderCollapsedClasses(result));
+        return result;
+    },
+
+    
+    
+    getHeaderCollapsedClasses: function(header) {
+        var me = this,
+            collapsedCls = me.collapsedCls,
+            collapsedClasses;
+
+        collapsedClasses = [ collapsedCls, collapsedCls + '-' + header.dock];
+        if (me.border && (!me.frame || (me.frame && Ext.supports.CSS3BorderRadius))) {
+            collapsedClasses.push(collapsedCls + '-border-' + header.dock);
+        }
+        return collapsedClasses;
+    },
+
+    
+    beginCollapse: function() {
+        var me = this,
+            lastBox = me.lastBox,
+            rendered = me.rendered,
+            collapseMemento = me.collapseMemento || (me.collapseMemento = new Ext.util.Memento(me)),
+            sizeModel = me.getSizeModel(),
+            reExpander;
+
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        collapseMemento.capture(['height', 'minHeight', 'width', 'minWidth']);
+        if (lastBox) {
+            collapseMemento.capture(me.restoreDimension(), lastBox, 'last.');
+        }
+        
+        
+        
+        
+        
+        if (me.collapsedVertical()) {
+            if (sizeModel.width.shrinkWrap) {
+                me.width = rendered ? me.getWidth() : me.width || me.minWidth || 100;
+            }
+            delete me.height;
+            me.minHeight = 0;
+        } else if (me.collapsedHorizontal()) {
+            if (sizeModel.height.shrinkWrap) {
+                me.height = rendered ? me.getHeight() : me.height || me.minHeight || 100;
+            }
+            delete me.width;
+            me.minWidth = 0;
+        }
+
+        if (me.ownerCt) {
+            me.ownerCt.getLayout().beginCollapse(me);
+        }
+
+        
+        
+        if (!me.isPlaceHolderCollapse()) {
+            if (me.header === (reExpander = me.getReExpander())) {
+                me.header.addClsWithUI(me.getHeaderCollapsedClasses(me.header));
+
+                
+                if (me.header.rendered) {
+                    me.header.updateFrame();
+                }
+            }
+            
+            else {
+                if (reExpander.el) {
+                    reExpander.el.show();
+                    reExpander.hidden = false;
+                }
+            }
+        }
+        if (me.resizer) {
+            me.resizer.disable();
+        }
+    },
+
+    beginExpand: function() {
+        var me = this,
+            lastBox = me.lastBox,
+            collapseMemento = me.collapseMemento,
+            restoreDimension = this.restoreDimension(),
+            reExpander;
+
+        collapseMemento.restore(['minHeight', 'minWidth', restoreDimension]);
+        if (lastBox) {
+            collapseMemento.restore(restoreDimension, true, lastBox, 'last.');
+        }
+
+        if (me.ownerCt) {
+            me.ownerCt.getLayout().beginExpand(me);
+        }
+
+        if (!me.isPlaceHolderCollapse()) {
+            
+            if (me.header === (reExpander = me.getReExpander())) {
+                me.header.removeClsWithUI(me.getHeaderCollapsedClasses(me.header));
+
+                
+                if (me.header.rendered) {
+                    me.header.updateFrame();
+                }
+            }
+            
+            else {
+                reExpander.hidden = true;
+                reExpander.el.hide();
+            }
+        }
+        if (me.resizer) {
+            me.resizer.enable();
+        }
+    },
+
+    
+    collapse: function(direction, animate) {
+        var me = this,
+            collapseDir = direction || me.collapseDirection,
+            ownerCt = me.ownerCt;
+
+        if (me.isCollapsingOrExpanding) {
+            return me;
+        }
+
+        if (arguments.length < 2) {
+            animate = me.animCollapse;
+        }
+
+        if (me.collapsed || me.fireEvent('beforecollapse', me, direction, animate) === false) {
+            return me;
+        }
+
+        if (ownerCt && me.isPlaceHolderCollapse()) {
+            return me.placeholderCollapse(direction, animate);
+        }
+
+        me.collapsed = collapseDir;
+        me.beginCollapse();
+
+        me.fireHierarchyEvent('collapse');
+
+        return me.doCollapseExpand(1, animate);
+    },
+
+    doCollapseExpand: function (flags, animate) {
+        var me = this,
+            originalAnimCollapse = me.animCollapse,
+            ownerLayout = me.ownerLayout;
+
+        
+        
+        me.animCollapse = animate;
+
+        
+        
+        me.isCollapsingOrExpanding = flags;
+
+        if (ownerLayout && !animate) {
+            ownerLayout.onContentChange(me);
+        } else {
+            me.updateLayout({ isRoot: true });
+        }
+
+        
+        me.animCollapse = originalAnimCollapse;
+
+        return me;
+    },
+
+    
+    afterCollapse: function(animated) {
+        var me = this,
+            ownerLayout = me.ownerLayout;
+
+        me.isCollapsingOrExpanding = 0;
+        if (me.collapseTool) {
+            me.collapseTool.setType('expand-' + me.getOppositeDirection(me.collapseDirection));
+        }
+
+        if (ownerLayout && animated) {
+            ownerLayout.onContentChange(me);
+        }
+
+        me.setHiddenDocked();
+        me.fireEvent('collapse', me);
+    },
+    
+    setHiddenDocked: function(){
+        
+        
+        var me = this,
+            toHide = me.hiddenOnCollapse,
+            reExpander = me.getReExpander(),
+            items = me.getDockedItems(),
+            len = items.length,
+            i = 0,
+            item;
+            
+        toHide.add(me.body);
+        for (; i < len; i++) {
+            item = items[i];
+            if (item && item !== reExpander && item.el) {
+                toHide.add(item.el);
+            }
+        }
+        toHide.setStyle('visibility', 'hidden');
+    },
+    
+    restoreHiddenDocked: function(){
+        var toShow = this.hiddenOnCollapse;
+        
+        toShow.setStyle('visibility', '');
+        toShow.clear();
+    },
+
+    getPlaceholder: function(direction) {
+        var me = this,
+            collapseDir = direction || me.collapseDirection,
+            listeners = null,
+            placeholder = me.placeholder;
+
+        if (!placeholder) {
+            if (me.floatable || (me.collapsible && me.titleCollapse)) {
+                listeners = {
+                    click: {
+                        fn: me.floatable ? me.floatCollapsedPanel : me.toggleCollapse,
+                        element: 'el',
+                        scope: me
+                    }
+                };
+            }
+
+            me.placeholder = placeholder = Ext.widget(me.createReExpander(collapseDir, {
+                id: me.id + '-placeholder',
+                listeners: listeners
+            }));
+        }
+
+        
+        if (!placeholder.placeholderFor) {
+            
+            if (!placeholder.isComponent) {
+                me.placeholder = placeholder = me.lookupComponent(placeholder);
+            }
+            Ext.applyIf(placeholder, {
+                margins: me.margins,
+                placeholderFor: me
+            });
+
+            placeholder.addCls([Ext.baseCSSPrefix + 'region-collapsed-placeholder', Ext.baseCSSPrefix + 'region-collapsed-' + collapseDir + '-placeholder', me.collapsedCls]);
+        }
+
+        return placeholder;
+    },
+
+    placeholderCollapse: function(direction, animate) {
+        var me = this,
+            ownerCt = me.ownerCt,
+            collapseDir = direction || me.collapseDirection,
+            floatCls = Ext.baseCSSPrefix + 'border-region-slide-in',
+            placeholder = me.getPlaceholder(direction);
+
+        me.isCollapsingOrExpanding = 1;
+
+        
+        me.hidden = true;
+        me.collapsed = collapseDir;
+
+        if (placeholder.rendered) {
+            
+            if (placeholder.el.dom.parentNode !== me.el.dom.parentNode) {
+                me.el.dom.parentNode.insertBefore(placeholder.el.dom, me.el.dom);
+            }
+
+            placeholder.hidden = false;
+            placeholder.el.show();
+            ownerCt.updateLayout();
+        } else {
+            ownerCt.insert(ownerCt.items.indexOf(me), placeholder);
+        }
+
+        if (me.rendered) {
+            
+            me.el.setVisibilityMode(me.placeholderCollapseHideMode);
+            if (animate) {
+                me.el.addCls(floatCls);
+                placeholder.el.hide();
+
+                me.el.slideOut(collapseDir.substr(0, 1), {
+                    preserveScroll: true,
+                    duration: Ext.Number.from(animate, Ext.fx.Anim.prototype.duration),
+                    listeners: {
+                        afteranimate: function() {
+                            me.el.removeCls(floatCls);
+                            
+                            placeholder.el.show().setStyle('display', 'none').slideIn(collapseDir.substr(0, 1), {
+                                easing: 'linear',
+                                duration: 100,
+                                listeners: {
+                                    afteranimate: function() {
+                                        placeholder.focus();
+                                        me.isCollapsingOrExpanding = 0;
+                                        me.fireEvent('collapse', me);
+                                    }
+                                }
+                            });
+                        }
+                    }
+                });
+            } else {
+                me.el.hide();
+                me.isCollapsingOrExpanding = 0;
+                me.fireEvent('collapse', me);
+            }
+        } else {
+            me.isCollapsingOrExpanding = 0;
+            me.fireEvent('collapse', me);
+        }
+
+        return me;
+    },
+
+    floatCollapsedPanel: function() {
+        var me = this,
+            placeholder = me.placeholder,
+            pb = placeholder.getBox(true),
+            myBox,
+            floatCls = Ext.baseCSSPrefix + 'border-region-slide-in',
+            collapsed = me.collapsed,
+            layoutOwner = me.ownerCt || me,
+            slideDirection;
+
+        
+        if (me.el.hasCls(floatCls)) {
+            me.slideOutFloatedPanel();
+            return;
+        }
+
+        if (me.isSliding) {
+            return;
+        }
+        me.isSliding = true;
+
+        
+        
+        function onMouseLeaveFloated(e) {
+            if (!me.isDestroyed) {
+                var slideRegion = me.el.getRegion().union(placeholder.el.getRegion()).adjust(1, -1, -1, 1);
+
+                
+                if (!slideRegion.contains(e.getPoint())) {
+                    me.slideOutFloatedPanel();
+                }
+            }
+        }
+
+        
+        me.placeholder.el.hide();
+        me.placeholder.hidden = true;
+        me.el.show();
+        me.hidden = false;
+        me.collapsed = false;
+        layoutOwner.updateLayout();
+        myBox = me.getBox(true);
+
+        
+        me.placeholder.el.show();
+        me.placeholder.hidden = false;
+        me.el.hide();
+        me.hidden = true;
+        me.collapsed = collapsed;
+        layoutOwner.updateLayout();
+
+        
+        me.placeholderMouseMon = placeholder.el.monitorMouseLeave(500, onMouseLeaveFloated);
+        me.panelMouseMon       = me.el.monitorMouseLeave(500, onMouseLeaveFloated);
+        me.el.addCls(floatCls);
+
+        
+        if (me.collapseTool) {
+            me.collapseTool.el.hide();
+        }
+
+        switch (me.collapsed) {
+            case 'top':
+                me.el.setLeftTop(pb.x, pb.y + pb.height - 1);
+                slideDirection = 't';
+                break;
+            case 'right':
+                me.el.setLeftTop(pb.x - myBox.width + 1, pb.y);
+                slideDirection = 'r';
+                break;
+            case 'bottom':
+                me.el.setLeftTop(pb.x, pb.y - myBox.height + 1);
+                slideDirection = 'b';
+                break;
+            case 'left':
+                me.el.setLeftTop(pb.x + pb.width - 1, pb.y);
+                slideDirection = 'l';
+                break;
+        }
+
+        
+        
+        me.floatedFromCollapse = me.collapsed;
+        me.collapsed = me.hidden = false;
+
+        me.el.slideIn(slideDirection, {
+            preserveScroll: true,
+            listeners: {
+                afteranimate: function() {
+                    me.isSliding = false;
+                }
+            }
+        });
+    },
+
+    isLayoutRoot: function() {
+        if (this.floatedFromCollapse) {
+            return true;
+        }
+        return this.callParent();
+    },
+
+    slideOutFloatedPanel: function() {
+        var me = this,
+            compEl = this.el,
+            collapseDirection;
+
+        if (me.isSliding) {
+            return;
+        }
+
+        me.isSliding = true;
+
+        me.slideOutFloatedPanelBegin();
+
+        if (typeof me.collapsed == 'string') {
+            collapseDirection = me.collapsed.charAt(0);
+        }
+
+        compEl.slideOut(collapseDirection, {
+            preserveScroll: true,
+            listeners: {
+                afteranimate: function() {
+                    me.slideOutFloatedPanelEnd();
+                    
+                    
+                    me.el.removeCls(Ext.baseCSSPrefix + 'border-region-slide-in');
+                    me.isSliding = false;
+                }
+            }
+        });
+    },
+
+    
+    slideOutFloatedPanelBegin: function() {
+        var me = this,
+            compEl = this.el;
+
+        me.collapsed = me.floatedFromCollapse;
+        me.hidden = true;
+        me.floatedFromCollapse = null;
+
+        
+        compEl.un(me.panelMouseMon);
+        me.placeholder.el.un(me.placeholderMouseMon);
+    },
+
+    
+    slideOutFloatedPanelEnd: function() {
+        if (this.collapseTool) {
+            this.collapseTool.el.show();
+        }
+    },
+
+    
+    expand: function(animate) {
+        var me = this;
+
+        if (me.isCollapsingOrExpanding) {
+            return me;
+        }
+
+        if (!arguments.length) {
+            animate = me.animCollapse;
+        }
+
+        if (!me.collapsed && !me.floatedFromCollapse) {
+            return me;
+        }
+
+        if (me.fireEvent('beforeexpand', me, animate) === false) {
+            return me;
+        }
+
+        if (me.isPlaceHolderCollapse()) {
+            return me.placeholderExpand(animate);
+        }
+
+        me.restoreHiddenDocked();
+        me.beginExpand();
+        me.collapsed = false;
+
+        me.fireHierarchyEvent('expand');
+
+        return me.doCollapseExpand(2, animate);
+    },
+
+    placeholderExpand: function(animate) {
+        var me = this,
+            collapseDir = me.collapsed,
+            floatCls = Ext.baseCSSPrefix + 'border-region-slide-in',
+            finalPos,
+            floatedPos,
+            slideInDirection;
+
+        if (me.floatedFromCollapse) {
+            floatedPos = me.getPosition(true);
+            
+            me.slideOutFloatedPanelBegin();
+            me.slideOutFloatedPanelEnd();
+        }
+
+        me.isCollapsingOrExpanding = 2;
+
+        
+        me.placeholder.hidden = true;
+        me.placeholder.el.hide();
+        me.collapsed = false;
+        me.show();
+
+        if (animate) {
+            
+            if (floatedPos) {
+                finalPos = me.el.getXY();
+                me.el.setLeftTop(floatedPos[0], floatedPos[1]);
+                me.el.moveTo(finalPos[0], finalPos[1], {
+                    duration: Ext.Number.from(animate, Ext.fx.Anim.prototype.duration),
+                    listeners: {
+                        afteranimate: function() {
+                            me.el.removeCls(floatCls);
+                            me.isCollapsingOrExpanding = 0;
+                            me.fireEvent('expand', me);
+                        }
+                    }
+                });
+            }
+            
+            else {
+                me.hidden = true;
+                me.el.addCls(floatCls);
+                me.el.hide();
+                me.collapsed = collapseDir;
+                me.placeholder.show();
+                slideInDirection = collapseDir.substr(0, 1);
+
+                
+                me.hidden = false;
+                me.el.slideIn(slideInDirection, {
+                    preserveScroll: true,
+                    duration: Ext.Number.from(animate, Ext.fx.Anim.prototype.duration),
+                    listeners: {
+                        afteranimate: function() {
+                            me.collapsed = false;
+
+                            
+                            
+                            
+                            
+                            
+                            me.el.removeCls(floatCls);
+                            me.placeholder.hide();
+
+                            me.isCollapsingOrExpanding = 0;
+                            me.fireEvent('expand', me);
+                        }
+                    }
+                });
+            }
+
+        } else {
+            me.isCollapsingOrExpanding = 0;
+            me.fireEvent('expand', me);
+        }
+
+        return me;
+    },
+
+    
+    afterExpand: function(animated) {
+        var me = this,
+            ownerLayout = me.ownerLayout;
+
+        me.isCollapsingOrExpanding = 0;
+        if (me.collapseTool) {
+            me.collapseTool.setType('collapse-' + me.collapseDirection);
+        }
+
+        if (ownerLayout && animated) {
+            ownerLayout.onContentChange(me);
+        }
+
+        me.fireEvent('expand', me);
+    },
+    
+    
+    setBorder: function(border, targetEl) {
+        if (targetEl) {
+            
+            return;
+        }
+        
+        var me = this,
+            header = me.header;
+            
+        if (!border) {
+            border = 0;
+        } else {
+            border = Ext.Element.unitizeBox((border === true) ? 1 : border);
+        }
+        
+        if (header) {
+            if (header.isHeader) {
+                header.setBorder(border);
+            } else {
+                header.border = border;
+            }
+        }
+        
+        if (me.rendered && me.bodyBorder !== false) {
+            me.body.setStyle('border-width', border);
+        }
+        me.updateLayout();
+        
+        me.border = border;
+    },
+
+    
+    toggleCollapse: function() {
+        return (this.collapsed || this.floatedFromCollapse) ? this.expand() : this.collapse();
+    },
+
+    
+    getKeyMap : function() {
+        return this.keyMap || (this.keyMap = new Ext.util.KeyMap(Ext.apply({
+            target: this.el
+        }, this.keys)));
+    },
+
+    
+    initDraggable : function(){
+        
+        this.dd = new Ext.panel.DD(this, Ext.isBoolean(this.draggable) ? null : this.draggable);
+    },
+
+    
+    ghostTools : function() {
+        var tools = [],
+            header = this.header,
+            headerTools = header ? header.query('tool[hidden=false]') : [],
+            t, tLen, tool;
+
+        if (headerTools.length) {
+            t = 0;
+            tLen = headerTools.length;
+
+            for (; t < tLen; t++) {
+                tool = headerTools[t];
+
+                
+                
+                
+                
+                tools.push({
+                    type: tool.type
+                });
+            }
+        } else {
+            tools = [{
+                type: 'placeholder'
+            }];
+        }
+        return tools;
+    },
+
+    
+    ghost: function(cls) {
+        var me = this,
+            ghostPanel = me.ghostPanel,
+            box = me.getBox(),
+            header;
+
+        if (!ghostPanel) {
+            ghostPanel = new Ext.panel.Panel({
+                renderTo: document.body,
+                floating: {
+                    shadow: false
+                },
+                frame: me.frame && !me.alwaysFramed,
+                alwaysFramed: me.alwaysFramed,
+                overlapHeader: me.overlapHeader,
+                headerPosition: me.headerPosition,
+                baseCls: me.baseCls,
+                cls: me.baseCls + '-ghost ' + (cls ||'')
+            });
+            me.ghostPanel = ghostPanel;
+        } else {
+            ghostPanel.el.show();
+        }
+        ghostPanel.floatParent = me.floatParent;
+        if (me.floating) {
+            ghostPanel.setZIndex(Ext.Number.from(me.el.getStyle('zIndex'), 0));
+        } else {
+            ghostPanel.toFront();
+        }
+        if (!(me.preventHeader || (me.header === false))) {
+            header = ghostPanel.header;
+            
+            if (header) {
+                header.suspendLayouts();
+                Ext.Array.forEach(header.query('tool'), header.remove, header);
+                header.resumeLayouts();
+            }
+            ghostPanel.addTool(me.ghostTools());
+            ghostPanel.setTitle(me.title);
+            ghostPanel.setIconCls(me.iconCls);
+        }
+
+        ghostPanel.setPagePosition(box.x, box.y);
+        ghostPanel.setSize(box.width, box.height);
+        me.el.hide();
+        return ghostPanel;
+    },
+
+    
+    unghost: function(show, matchPosition) {
+        var me = this;
+        if (!me.ghostPanel) {
+            return;
+        }
+        if (show !== false) {
+            
+            
+            me.el.show();
+            if (matchPosition !== false) {
+                me.setPagePosition(me.ghostPanel.el.getXY());
+                if (me.hideMode == 'offsets') {
+                    
+                    delete me.el.hideModeStyles;
+                }
+            }
+            Ext.defer(me.focus, 10, me);
+        }
+        me.ghostPanel.el.hide();
+    },
+
+    beginDrag: function() {
+        if (this.floatingDescendants) {
+            this.floatingDescendants.hide();
+        }
+    },
+
+    endDrag: function() {
+        if (this.floatingDescendants) {
+            this.floatingDescendants.show();
+        }
+    },
+
+    initResizable: function(resizable) {
+        if (this.collapsed) {
+            resizable.disabled = true;
+        }
+        this.callParent([resizable]);
+    }
+}, function() {
+    this.prototype.animCollapse = Ext.enableFx;
+});
+
+
+Ext.define('Ext.tip.Tip', {
+    extend: 'Ext.panel.Panel',
+
+    alternateClassName: 'Ext.Tip',
+
+    
+    
+    
+    minWidth : 40,
+    
+    maxWidth : 300,
+    
+    shadow : "sides",
+
+    
+    defaultAlign : "tl-bl?",
+    
+    constrainPosition : true,
+
+    
+    autoRender: true,
+    hidden: true,
+    baseCls: Ext.baseCSSPrefix + 'tip',
+    floating: {
+        shadow: true,
+        shim: true,
+        constrain: true
+    },
+    focusOnToFront: false,
+
+    
+    closeAction: 'hide',
+
+    ariaRole: 'tooltip',
+
+    
+    alwaysFramed: true,
+
+    frameHeader: false,
+
+    initComponent: function() {
+        var me = this;
+
+        me.floating = Ext.apply({}, {shadow: me.shadow}, me.self.prototype.floating);
+        me.callParent(arguments);
+
+        
+        me.constrain = me.constrain || me.constrainPosition;
+    },
+
+    
+    showAt : function(xy){
+        var me = this;
+        this.callParent(arguments);
+        
+        if (me.isVisible()) {
+            me.setPagePosition(xy[0], xy[1]);
+            if (me.constrainPosition || me.constrain) {
+                me.doConstrain();
+            }
+            me.toFront(true);
+        }
+    },
+
+    
+    showBy : function(el, pos) {
+        this.showAt(this.el.getAlignToXY(el, pos || this.defaultAlign));
+    },
+
+    
+    initDraggable : function(){
+        var me = this;
+        me.draggable = {
+            el: me.getDragEl(),
+            delegate: me.header.el,
+            constrain: me,
+            constrainTo: me.el.getScopeParent()
+        };
+        
+        Ext.Component.prototype.initDraggable.call(me);
+    },
+
+    
+    ghost: undefined,
+    unghost: undefined
+});
+
+
+Ext.define('Ext.tip.ToolTip', {
+    extend: 'Ext.tip.Tip',
+    alias: 'widget.tooltip',
+    alternateClassName: 'Ext.ToolTip',
+    
+    
+    
+    autoHide: true,
+    
+    
+    showDelay: 500,
+    
+    hideDelay: 200,
+    
+    dismissDelay: 5000,
+    
+    
+    trackMouse: false,
+    
+    
+    anchorToTarget: true,
+    
+    anchorOffset: 0,
+    
+
+    
+    targetCounter: 0,
+    quickShowInterval: 250,
+
+    
+    initComponent: function() {
+        var me = this;
+        me.callParent(arguments);
+        me.lastActive = new Date();
+        me.setTarget(me.target);
+        me.origAnchor = me.anchor;
+    },
+
+    
+    onRender: function(ct, position) {
+        var me = this;
+        me.callParent(arguments);
+        me.anchorCls = Ext.baseCSSPrefix + 'tip-anchor-' + me.getAnchorPosition();
+        me.anchorEl = me.el.createChild({
+            cls: Ext.baseCSSPrefix + 'tip-anchor ' + me.anchorCls
+        });
+    },
+
+    
+    setTarget: function(target) {
+        var me = this,
+            t = Ext.get(target),
+            tg;
+
+        if (me.target) {
+            tg = Ext.get(me.target);
+            me.mun(tg, 'mouseover', me.onTargetOver, me);
+            me.mun(tg, 'mouseout', me.onTargetOut, me);
+            me.mun(tg, 'mousemove', me.onMouseMove, me);
+        }
+
+        me.target = t;
+        if (t) {
+
+            me.mon(t, {
+                
+                
+                freezeEvent: true,
+
+                mouseover: me.onTargetOver,
+                mouseout: me.onTargetOut,
+                mousemove: me.onMouseMove,
+                scope: me
+            });
+        }
+        if (me.anchor) {
+            me.anchorTarget = me.target;
+        }
+    },
+
+    
+    onMouseMove: function(e) {
+        var me = this,
+            t = me.delegate ? e.getTarget(me.delegate) : me.triggerElement = true,
+            xy;
+        if (t) {
+            me.targetXY = e.getXY();
+            if (t === me.triggerElement) {
+                if (!me.hidden && me.trackMouse) {
+                    xy = me.getTargetXY();
+                    if (me.constrainPosition) {
+                        xy = me.el.adjustForConstraints(xy, me.el.getScopeParent());
+                    }
+                    me.setPagePosition(xy);
+                }
+            } else {
+                me.hide();
+                me.lastActive = new Date(0);
+                me.onTargetOver(e);
+            }
+        } else if ((!me.closable && me.isVisible()) && me.autoHide !== false) {
+            me.hide();
+        }
+    },
+
+    
+    getTargetXY: function() {
+        var me = this,
+            mouseOffset,
+            offsets, xy, dw, dh, de, bd, scrollX, scrollY, axy, sz, constrainPosition;
+        if (me.delegate) {
+            me.anchorTarget = me.triggerElement;
+        }
+        if (me.anchor) {
+            me.targetCounter++;
+            offsets = me.getOffsets();
+            xy = (me.anchorToTarget && !me.trackMouse) ? me.el.getAlignToXY(me.anchorTarget, me.getAnchorAlign()) : me.targetXY;
+            dw = Ext.Element.getViewWidth() - 5;
+            dh = Ext.Element.getViewHeight() - 5;
+            de = document.documentElement;
+            bd = document.body;
+            scrollX = (de.scrollLeft || bd.scrollLeft || 0) + 5;
+            scrollY = (de.scrollTop || bd.scrollTop || 0) + 5;
+            axy = [xy[0] + offsets[0], xy[1] + offsets[1]];
+            sz = me.getSize();
+            constrainPosition = me.constrainPosition;
+
+            me.anchorEl.removeCls(me.anchorCls);
+
+            if (me.targetCounter < 2 && constrainPosition) {
+                if (axy[0] < scrollX) {
+                    if (me.anchorToTarget) {
+                        me.defaultAlign = 'l-r';
+                        if (me.mouseOffset) {
+                            me.mouseOffset[0] *= -1;
+                        }
+                    }
+                    me.anchor = 'left';
+                    return me.getTargetXY();
+                }
+                if (axy[0] + sz.width > dw) {
+                    if (me.anchorToTarget) {
+                        me.defaultAlign = 'r-l';
+                        if (me.mouseOffset) {
+                            me.mouseOffset[0] *= -1;
+                        }
+                    }
+                    me.anchor = 'right';
+                    return me.getTargetXY();
+                }
+                if (axy[1] < scrollY) {
+                    if (me.anchorToTarget) {
+                        me.defaultAlign = 't-b';
+                        if (me.mouseOffset) {
+                            me.mouseOffset[1] *= -1;
+                        }
+                    }
+                    me.anchor = 'top';
+                    return me.getTargetXY();
+                }
+                if (axy[1] + sz.height > dh) {
+                    if (me.anchorToTarget) {
+                        me.defaultAlign = 'b-t';
+                        if (me.mouseOffset) {
+                            me.mouseOffset[1] *= -1;
+                        }
+                    }
+                    me.anchor = 'bottom';
+                    return me.getTargetXY();
+                }
+            }
+
+            me.anchorCls = Ext.baseCSSPrefix + 'tip-anchor-' + me.getAnchorPosition();
+            me.anchorEl.addCls(me.anchorCls);
+            me.targetCounter = 0;
+            return axy;
+        } else {
+            mouseOffset = me.getMouseOffset();
+            return (me.targetXY) ? [me.targetXY[0] + mouseOffset[0], me.targetXY[1] + mouseOffset[1]] : mouseOffset;
+        }
+    },
+
+    getMouseOffset: function() {
+        var me = this,
+        offset = me.anchor ? [0, 0] : [15, 18];
+        if (me.mouseOffset) {
+            offset[0] += me.mouseOffset[0];
+            offset[1] += me.mouseOffset[1];
+        }
+        return offset;
+    },
+
+    
+    getAnchorPosition: function() {
+        var me = this,
+            m;
+        if (me.anchor) {
+            me.tipAnchor = me.anchor.charAt(0);
+        } else {
+            m = me.defaultAlign.match(/^([a-z]+)-([a-z]+)(\?)?$/);
+            me.tipAnchor = m[1].charAt(0);
+        }
+
+        switch (me.tipAnchor) {
+        case 't':
+            return 'top';
+        case 'b':
+            return 'bottom';
+        case 'r':
+            return 'right';
+        }
+        return 'left';
+    },
+
+    
+    getAnchorAlign: function() {
+        switch (this.anchor) {
+        case 'top':
+            return 'tl-bl';
+        case 'left':
+            return 'tl-tr';
+        case 'right':
+            return 'tr-tl';
+        default:
+            return 'bl-tl';
+        }
+    },
+
+    
+    getOffsets: function() {
+        var me = this,
+            mouseOffset,
+            offsets,
+            ap = me.getAnchorPosition().charAt(0);
+        if (me.anchorToTarget && !me.trackMouse) {
+            switch (ap) {
+            case 't':
+                offsets = [0, 9];
+                break;
+            case 'b':
+                offsets = [0, -13];
+                break;
+            case 'r':
+                offsets = [ - 13, 0];
+                break;
+            default:
+                offsets = [9, 0];
+                break;
+            }
+        } else {
+            switch (ap) {
+            case 't':
+                offsets = [ - 15 - me.anchorOffset, 30];
+                break;
+            case 'b':
+                offsets = [ - 19 - me.anchorOffset, -13 - me.el.dom.offsetHeight];
+                break;
+            case 'r':
+                offsets = [ - 15 - me.el.dom.offsetWidth, -13 - me.anchorOffset];
+                break;
+            default:
+                offsets = [25, -13 - me.anchorOffset];
+                break;
+            }
+        }
+        mouseOffset = me.getMouseOffset();
+        offsets[0] += mouseOffset[0];
+        offsets[1] += mouseOffset[1];
+
+        return offsets;
+    },
+
+    
+    onTargetOver: function(e) {
+        var me = this,
+            t;
+
+        if (me.disabled || e.within(me.target.dom, true)) {
+            return;
+        }
+        t = e.getTarget(me.delegate);
+        if (t) {
+            me.triggerElement = t;
+            me.clearTimer('hide');
+            me.targetXY = e.getXY();
+            me.delayShow();
+        }
+    },
+
+    
+    delayShow: function() {
+        var me = this;
+        if (me.hidden && !me.showTimer) {
+            if (Ext.Date.getElapsed(me.lastActive) < me.quickShowInterval) {
+                me.show();
+            } else {
+                me.showTimer = Ext.defer(me.show, me.showDelay, me);
+            }
+        }
+        else if (!me.hidden && me.autoHide !== false) {
+            me.show();
+        }
+    },
+    
+    onShowVeto: function(){
+        this.callParent();
+        this.clearTimer('show');
+    },
+
+    
+    onTargetOut: function(e) {
+        var me = this;
+
+        
+        
+        if (me.disabled || e.within(me.target.dom, true)) {
+            return;
+        }
+        me.clearTimer('show');
+        if (me.autoHide !== false) {
+            me.delayHide();
+        }
+    },
+
+    
+    delayHide: function() {
+        var me = this;
+        if (!me.hidden && !me.hideTimer) {
+            me.hideTimer = Ext.defer(me.hide, me.hideDelay, me);
+        }
+    },
+
+    
+    hide: function() {
+        var me = this;
+        me.clearTimer('dismiss');
+        me.lastActive = new Date();
+        if (me.anchorEl) {
+            me.anchorEl.hide();
+        }
+        me.callParent(arguments);
+        delete me.triggerElement;
+    },
+
+    
+    show: function() {
+        var me = this;
+
+        
+        
+        this.callParent();
+        if (this.hidden === false) {
+            me.setPagePosition(-10000, -10000);
+
+            if (me.anchor) {
+                me.anchor = me.origAnchor;
+            }
+            
+            if (!me.calledFromShowAt) {
+                me.showAt(me.getTargetXY());
+            }
+
+            if (me.anchor) {
+                me.syncAnchor();
+                me.anchorEl.show();
+            } else {
+                me.anchorEl.hide();
+            }
+        }
+    },
+
+    
+    showAt: function(xy) {
+        var me = this;
+        me.lastActive = new Date();
+        me.clearTimers();
+        me.calledFromShowAt = true;
+
+        
+        if (!me.isVisible()) {
+            this.callParent(arguments);
+        }
+
+        
+        if (me.isVisible()) {
+            me.setPagePosition(xy[0], xy[1]);
+            if (me.constrainPosition || me.constrain) {
+                me.doConstrain();
+            }
+            me.toFront(true);
+            me.el.sync(true);
+            if (me.dismissDelay && me.autoHide !== false) {
+                me.dismissTimer = Ext.defer(me.hide, me.dismissDelay, me);
+            }
+            if (me.anchor) {
+                me.syncAnchor();
+                if (!me.anchorEl.isVisible()) {
+                    me.anchorEl.show();
+                }
+            } else {
+                me.anchorEl.hide();
+            }
+        }
+        delete me.calledFromShowAt;
+    },
+
+    
+    syncAnchor: function() {
+        var me = this,
+            anchorPos,
+            targetPos,
+            offset;
+        switch (me.tipAnchor.charAt(0)) {
+        case 't':
+            anchorPos = 'b';
+            targetPos = 'tl';
+            offset = [20 + me.anchorOffset, 1];
+            break;
+        case 'r':
+            anchorPos = 'l';
+            targetPos = 'tr';
+            offset = [ - 1, 12 + me.anchorOffset];
+            break;
+        case 'b':
+            anchorPos = 't';
+            targetPos = 'bl';
+            offset = [20 + me.anchorOffset, -1];
+            break;
+        default:
+            anchorPos = 'r';
+            targetPos = 'tl';
+            offset = [1, 12 + me.anchorOffset];
+            break;
+        }
+        me.anchorEl.alignTo(me.el, anchorPos + '-' + targetPos, offset);
+        me.anchorEl.setStyle('z-index', parseInt(me.el.getZIndex(), 10) || 0 + 1).setVisibilityMode(Ext.Element.DISPLAY);
+    },
+
+    
+    setPagePosition: function(x, y) {
+        var me = this;
+        me.callParent(arguments);
+        if (me.anchor) {
+            me.syncAnchor();
+        }
+    },
+
+    
+    clearTimer: function(name) {
+        name = name + 'Timer';
+        clearTimeout(this[name]);
+        delete this[name];
+    },
+
+    
+    clearTimers: function() {
+        var me = this;
+        me.clearTimer('show');
+        me.clearTimer('dismiss');
+        me.clearTimer('hide');
+    },
+
+    
+    onShow: function() {
+        var me = this;
+        me.callParent();
+        me.mon(Ext.getDoc(), 'mousedown', me.onDocMouseDown, me);
+    },
+
+    
+    onHide: function() {
+        var me = this;
+        me.callParent();
+        me.mun(Ext.getDoc(), 'mousedown', me.onDocMouseDown, me);
+    },
+
+    
+    onDocMouseDown: function(e) {
+        var me = this;
+        if (!me.closable && !e.within(me.el.dom)) {
+            me.disable();
+            Ext.defer(me.doEnable, 100, me);
+        }
+    },
+
+    
+    doEnable: function() {
+        if (!this.isDestroyed) {
+            this.enable();
+        }
+    },
+
+    
+    onDisable: function() {
+        this.callParent();
+        this.clearTimers();
+        this.hide();
+    },
+
+    beforeDestroy: function() {
+        var me = this;
+        me.clearTimers();
+        Ext.destroy(me.anchorEl);
+        delete me.anchorEl;
+        delete me.target;
+        delete me.anchorTarget;
+        delete me.triggerElement;
+        me.callParent();
+    },
+
+    
+    onDestroy: function() {
+        Ext.getDoc().un('mousedown', this.onDocMouseDown, this);
+        this.callParent();
+    }
+});
+
+
+Ext.define('Ext.tip.QuickTip', {
+    extend: 'Ext.tip.ToolTip',
+    alias: 'widget.quicktip',
+    alternateClassName: 'Ext.QuickTip',
+
+    
+
+    
+    interceptTitles : false,
+
+    
+    title: '&#160;',
+
+    
+    tagConfig : {
+        namespace : "data-",
+        attribute : "qtip",
+        width : "qwidth",
+        target : "target",
+        title : "qtitle",
+        hide : "hide",
+        cls : "qclass",
+        align : "qalign",
+        anchor : "anchor"
+    },
+
+    
+    initComponent : function(){
+        var me = this;
+
+        me.target = me.target || Ext.getDoc();
+        me.targets = me.targets || {};
+        me.callParent();
+    },
+
+    
+    register : function(config){
+        var configs = Ext.isArray(config) ? config : arguments,
+            i = 0,
+            len = configs.length,
+            target, j, targetLen;
+
+        for (; i < len; i++) {
+            config = configs[i];
+            target = config.target;
+            if (target) {
+                if (Ext.isArray(target)) {
+                    for (j = 0, targetLen = target.length; j < targetLen; j++) {
+                        this.targets[Ext.id(target[j])] = config;
+                    }
+                } else{
+                    this.targets[Ext.id(target)] = config;
+                }
+            }
+        }
+    },
+
+    
+    unregister : function(el){
+        delete this.targets[Ext.id(el)];
+    },
+
+    
+    cancelShow: function(el){
+        var me = this,
+            activeTarget = me.activeTarget;
+
+        el = Ext.get(el).dom;
+        if (me.isVisible()) {
+            if (activeTarget && activeTarget.el == el) {
+                me.hide();
+            }
+        } else if (activeTarget && activeTarget.el == el) {
+            me.clearTimer('show');
+        }
+    },
+
+    
+    getTipCfg: function(e) {
+        var t = e.getTarget(),
+            titleText = t.title,
+            cfg;
+
+        if (this.interceptTitles && titleText && Ext.isString(titleText)) {
+            t.qtip = titleText;
+            t.removeAttribute("title");
+            e.preventDefault();
+            return {
+                text: titleText
+            };
+        }
+        else {
+            cfg = this.tagConfig;
+            t = e.getTarget('[' + cfg.namespace + cfg.attribute + ']');
+            if (t) {
+                return {
+                    target: t,
+                    text: t.getAttribute(cfg.namespace + cfg.attribute)
+                };
+            }
+        }
+    },
+
+    
+    onTargetOver : function(e){
+        var me = this,
+            target = e.getTarget(me.delegate),
+            hasShowDelay,
+            delay,
+            elTarget,
+            cfg,
+            ns,
+            tipConfig,
+            autoHide,
+            targets, targetEl, value, key;
+
+        if (me.disabled) {
+            return;
+        }
+
+        
+        
+        
+        me.targetXY = e.getXY();
+
+        
+        if(!target || target.nodeType !== 1 || target == document.documentElement || target == document.body){
+            return;
+        }
+
+        if (me.activeTarget && ((target == me.activeTarget.el) || Ext.fly(me.activeTarget.el).contains(target))) {
+            me.clearTimer('hide');
+            me.show();
+            return;
+        }
+
+        if (target) {
+            targets = me.targets;
+
+            for (key in targets) {
+                if (targets.hasOwnProperty(key)) {
+                    value = targets[key];
+
+                    targetEl = Ext.fly(value.target);
+                    if (targetEl && (targetEl.dom === target || targetEl.contains(target))) {
+                        elTarget = targetEl.dom;
+                        break;
+                    }
+                }
+            }
+
+            if (elTarget) {
+                me.activeTarget = me.targets[elTarget.id];
+                me.activeTarget.el = target;
+                me.anchor = me.activeTarget.anchor;
+                if (me.anchor) {
+                    me.anchorTarget = target;
+                }
+                hasShowDelay = Ext.isDefined(me.activeTarget.showDelay);
+                if (hasShowDelay) {
+                    delay = me.showDelay;
+                    me.showDelay = me.activeTarget.showDelay;
+                }
+                me.delayShow();
+                if (hasShowDelay) {
+                    me.showDelay = delay;
+                }
+                return;
+            }
+        }
+
+        
+        elTarget = Ext.fly(target, '_quicktip-target');
+        cfg = me.tagConfig;
+        ns = cfg.namespace;
+        tipConfig = me.getTipCfg(e);
+
+        if (tipConfig) {
+
+            
+            
+            if (tipConfig.target) {
+                target = tipConfig.target;
+                elTarget = Ext.fly(target, '_quicktip-target');
+            }
+            autoHide = elTarget.getAttribute(ns + cfg.hide);
+
+            me.activeTarget = {
+                el: target,
+                text: tipConfig.text,
+                width: +elTarget.getAttribute(ns + cfg.width) || null,
+                autoHide: autoHide != "user" && autoHide !== 'false',
+                title: elTarget.getAttribute(ns + cfg.title),
+                cls: elTarget.getAttribute(ns + cfg.cls),
+                align: elTarget.getAttribute(ns + cfg.align)
+
+            };
+            me.anchor = elTarget.getAttribute(ns + cfg.anchor);
+            if (me.anchor) {
+                me.anchorTarget = target;
+            }
+            hasShowDelay = Ext.isDefined(me.activeTarget.showDelay);
+            if (hasShowDelay) {
+                delay = me.showDelay;
+                me.showDelay = me.activeTarget.showDelay;
+            }
+            me.delayShow();
+            if (hasShowDelay) {
+                me.showDelay = delay;
+            }
+        }
+    },
+
+    
+    onTargetOut : function(e){
+        var me = this,
+            active = me.activeTarget,
+            hasHideDelay,
+            delay;
+
+        
+        
+        if (active && e.within(me.activeTarget.el) && !me.getTipCfg(e)) {
+            return;
+        }
+
+        me.clearTimer('show');
+        delete me.activeTarget;
+        if (me.autoHide !== false) {
+            hasHideDelay = active && Ext.isDefined(active.hideDelay);
+            if (hasHideDelay) {
+                delay = me.hideDelay;
+                me.hideDelay = active.hideDelay;
+            }
+            me.delayHide();
+            if (hasHideDelay) {
+                me.hideDelay = delay;
+            }
+        }
+    },
+
+    
+    showAt : function(xy){
+        var me = this,
+            target = me.activeTarget,
+            cls;
+
+        if (target) {
+            if (!me.rendered) {
+                me.render(Ext.getBody());
+                me.activeTarget = target;
+            }
+            me.suspendLayouts();
+            if (target.title) {
+                me.setTitle(target.title);
+                me.header.show();
+            } else {
+                me.header.hide();
+            }
+            me.update(target.text);
+            me.autoHide = target.autoHide;
+            me.dismissDelay = target.dismissDelay || me.dismissDelay;
+            if (target.mouseOffset) {
+                xy[0] += target.mouseOffset[0];
+                xy[1] += target.mouseOffset[1];
+            }
+
+            cls = me.lastCls;
+            if (cls) {
+                me.removeCls(cls);
+                delete me.lastCls;
+            }
+
+            cls = target.cls;
+            if (cls) {
+                me.addCls(cls);
+                me.lastCls = cls;
+            }
+
+            me.setWidth(target.width);
+
+            if (me.anchor) {
+                me.constrainPosition = false;
+            } else if (target.align) { 
+                xy = me.el.getAlignToXY(target.el, target.align);
+                me.constrainPosition = false;
+            }else{
+                me.constrainPosition = true;
+            }
+            me.resumeLayouts(true);
+        }
+        me.callParent([xy]);
+    },
+
+    
+    hide: function(){
+        delete this.activeTarget;
+        this.callParent();
+    }
+});
+
+
+Ext.define('Ext.tip.QuickTipManager', (function() {
+    var tip,
+        disabled = false;
+
+    return {
+        requires: ['Ext.tip.QuickTip'],
+        singleton: true,
+        alternateClassName: 'Ext.QuickTips',
+
+        
+        init : function (autoRender, config) {
+            if (!tip) {
+                if (!Ext.isReady) {
+                    Ext.onReady(function(){
+                        Ext.tip.QuickTipManager.init(autoRender, config);
+                    });
+                    return;
+                }
+
+                var tipConfig = Ext.apply({ disabled: disabled, id: 'ext-quicktips-tip' }, config),
+                    className = tipConfig.className,
+                    xtype = tipConfig.xtype;
+
+                if (className) {
+                    delete tipConfig.className;
+                } else if (xtype) {
+                    className = 'widget.' + xtype;
+                    delete tipConfig.xtype;
+                }
+
+                if (autoRender !== false) {
+                    tipConfig.renderTo = document.body;
+
+                }
+
+                tip = Ext.create(className || 'Ext.tip.QuickTip', tipConfig);
+            }
+        },
+
+        
+        destroy: function() {
+            if (tip) {
+                var undef;
+                tip.destroy();
+                tip = undef;
+            }
+        },
+
+        
+        ddDisable : function(){
+            
+            if(tip && !disabled){
+                tip.disable();
+            }
+        },
+
+        
+        ddEnable : function(){
+            
+            if(tip && !disabled){
+                tip.enable();
+            }
+        },
+
+        
+        enable : function(){
+            if(tip){
+                tip.enable();
+            }
+            disabled = false;
+        },
+
+        
+        disable : function(){
+            if(tip){
+                tip.disable();
+            }
+            disabled = true;
+        },
+
+        
+        isEnabled : function(){
+            return tip !== undefined && !tip.disabled;
+        },
+
+        
+        getQuickTip : function(){
+            return tip;
+        },
+
+        
+        register : function(){
+            tip.register.apply(tip, arguments);
+        },
+
+        
+        unregister : function(){
+            tip.unregister.apply(tip, arguments);
+        },
+
+        
+        tips : function(){
+            tip.register.apply(tip, arguments);
+        }
+    };
+}()));
+
+
+Ext.define('Ext.app.EventBus', {
+    requires: [
+        'Ext.util.Event',
+        'Ext.Component'
+    ],
+    mixins: {
+        observable: 'Ext.util.Observable'
+    },
+
+    constructor: function() {
+        this.mixins.observable.constructor.call(this);
+
+        this.bus = {};
+
+        var me = this;
+        Ext.override(Ext.Component, {
+            fireEvent: function(ev) {
+                if (Ext.util.Observable.prototype.fireEvent.apply(this, arguments) !== false) {
+                    return me.dispatch.call(me, ev, this, arguments);
+                }
+                return false;
+            }
+        });
+    },
+
+    dispatch: function(ev, target, args) {
+        var bus = this.bus,
+            selectors = bus[ev],
+            selector, controllers, id, events, event, i, ln;
+
+        if (selectors) {
+            
+            for (selector in selectors) {
+                
+                if (selectors.hasOwnProperty(selector) && target.is(selector)) {
+                    
+                    controllers = selectors[selector];
+                    for (id in controllers) {
+                        if (controllers.hasOwnProperty(id)) {
+                            
+                            events = controllers[id];
+                            for (i = 0, ln = events.length; i < ln; i++) {
+                                event = events[i];
+                                
+                                if (event.fire.apply(event, Array.prototype.slice.call(args, 1)) === false) {
+                                    return false;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return true;
+    },
+
+    control: function(selectors, listeners, controller) {
+        var bus = this.bus,
+            hasListeners, tree, list,
+            selector, options, listener, scope, event, listenerList, ev;
+
+        if (Ext.isString(selectors)) {
+            selector = selectors;
+            selectors = {};
+            selectors[selector] = listeners;
+            this.control(selectors, null, controller);
+            return;
+        }
+
+        hasListeners = Ext.util.Observable.HasListeners.prototype;
+        for (selector in selectors) {
+            if (selectors.hasOwnProperty(selector)) {
+                listenerList = selectors[selector] || {};
+
+                for (ev in listenerList) {
+                    if (listenerList.hasOwnProperty(ev)) {
+                        options  = {};
+                        listener = listenerList[ev];
+                        scope    = controller;
+                        event    = new Ext.util.Event(controller, ev);
+
+                        
+                        if (Ext.isObject(listener)) {
+                            options  = listener;
+                            listener = options.fn;
+                            scope    = options.scope || controller;
+
+                            delete options.fn;
+                            delete options.scope;
+                        }
+
+                        event.addListener(listener, scope, options);
+
+                        hasListeners[ev] = 1;
+
+                        
+                        tree = bus[ev] || (bus[ev] = {});
+                        tree = tree[selector] || (tree[selector] = {});
+                        list = tree[controller.id] || (tree[controller.id] = []);
+
+                        
+                        list.push(event);
+                    }
+                } 
+            }
+        } 
+    }
+});
+
+
+Ext.define('Ext.app.Application', {
+    extend: 'Ext.app.Controller',
+
+    requires: [
+        'Ext.ModelManager',
+        'Ext.data.Model',
+        'Ext.data.StoreManager',
+        'Ext.tip.QuickTipManager',
+        'Ext.ComponentManager',
+        'Ext.app.EventBus'
+    ],
+
+    
+
+    
+
+    
+    scope: undefined,
+
+    
+    enableQuickTips: true,
+
+    
+    appFolder: 'app',
+
+    
+    autoCreateViewport: false,
+    
+    
+    
+    
+    constructor: function(config) {
+        config = config || {};
+        Ext.apply(this, config);
+
+        var me = this,
+            requires = config.requires || [],
+            controllers, ln, i, controller,
+            paths, path, ns;
+
+        Ext.Loader.setPath(me.name, me.appFolder);
+
+        if (me.paths) {
+            paths = me.paths;
+
+            for (ns in paths) {
+                if (paths.hasOwnProperty(ns)) {
+                    path = paths[ns];
+
+                    Ext.Loader.setPath(ns, path);
+                }
+            }
+        }
+
+        me.callParent(arguments);
+
+        me.eventbus = new Ext.app.EventBus;
+
+        controllers = Ext.Array.from(me.controllers);
+        ln = controllers && controllers.length;
+
+        me.controllers = new Ext.util.MixedCollection();
+
+        if (me.autoCreateViewport) {
+            requires.push(me.getModuleClassName('Viewport', 'view'));
+        }
+
+        for (i = 0; i < ln; i++) {
+            requires.push(me.getModuleClassName(controllers[i], 'controller'));
+        }
+
+        Ext.require(requires);
+
+        Ext.onReady(function() {
+            me.init(me);
+            for (i = 0; i < ln; i++) {
+                controller = me.getController(controllers[i]);
+                controller.init(me);
+            }
+
+            me.onBeforeLaunch.call(me);
+        }, me);
+    },
+
+    control: function(selectors, listeners, controller) {
+        this.eventbus.control(selectors, listeners, controller);
+    },
+
+    
+    launch: Ext.emptyFn,
+
+    
+    onBeforeLaunch: function() {
+        var me = this,
+            controllers, c, cLen, controller;
+
+        if (me.enableQuickTips) {
+            Ext.tip.QuickTipManager.init();
+        }
+
+        if (me.autoCreateViewport) {
+            me.getView('Viewport').create();
+        }
+
+        me.launch.call(this.scope || this);
+        me.launched = true;
+        me.fireEvent('launch', this);
+
+        controllers = me.controllers.items;
+        cLen        = controllers.length;
+
+        for (c = 0; c < cLen; c++) {
+            controller = controllers[c];
+            controller.onLaunch(this);
+        }
+    },
+
+    getModuleClassName: function(name, module) {
+        
+        
+        
+        
+        
+        
+        
+        if (name.indexOf('.') !== -1 && (Ext.ClassManager.isCreated(name) || Ext.Loader.isAClassNameWithAKnownPrefix(name))) {
+            return name;
+        } else {
+            return this.name + '.' + module + '.' + name;
+        }
+    },
+
+    getController: function(name) {
+        var controller = this.controllers.get(name);
+
+        if (!controller) {
+            controller = Ext.create(this.getModuleClassName(name, 'controller'), {
+                application: this,
+                id: name
+            });
+
+            this.controllers.add(controller);
+        }
+
+        return controller;
+    },
+
+    getStore: function(name) {
+        var store = Ext.StoreManager.get(name);
+
+        if (!store) {
+            store = Ext.create(this.getModuleClassName(name, 'store'), {
+                storeId: name
+            });
+        }
+
+        return store;
+    },
+
+    getModel: function(model) {
+        model = this.getModuleClassName(model, 'model');
+
+        return Ext.ModelManager.getModel(model);
+    },
+
+    getView: function(view) {
+        view = this.getModuleClassName(view, 'view');
+
+        return Ext.ClassManager.get(view);
+    }
+});
+
+
+Ext.define('Ext.button.Split', {
+
+    
+    alias: 'widget.splitbutton',
+
+    extend: 'Ext.button.Button',
+    alternateClassName: 'Ext.SplitButton',
+    
+    
+    
+    
+
+    
+    arrowCls      : 'split',
+    split         : true,
+
+    
+    initComponent : function(){
+        this.callParent();
+        
+        this.addEvents("arrowclick");
+    },
+
+    
+    setArrowHandler : function(handler, scope){
+        this.arrowHandler = handler;
+        this.scope = scope;
+    },
+
+    
+    onClick : function(e, t) {
+        var me = this;
+        
+        e.preventDefault();
+        if (!me.disabled) {
+            if (me.overMenuTrigger) {
+                me.maybeShowMenu();
+                me.fireEvent("arrowclick", me, e);
+                if (me.arrowHandler) {
+                    me.arrowHandler.call(me.scope || me, me, e);
+                }
+            } else {
+                me.doToggle();
+                me.fireHandler(e);
+            }
+        }
+    }
+});
+
+
+Ext.define('Ext.button.Cycle', {
+
+    
+
+    alias: 'widget.cycle',
+
+    extend: 'Ext.button.Split',
+    alternateClassName: 'Ext.CycleButton',
+
+    
+
+    
+    
+    
+    
+    
+    
+
+    
+    getButtonText: function(item) {
+        var me = this,
+            text = '';
+
+        if (item && me.showText === true) {
+            if (me.prependText) {
+                text += me.prependText;
+            }
+            text += item.text;
+            return text;
+        }
+        return me.text;
+    },
+
+    
+    setActiveItem: function(item, suppressEvent) {
+        var me = this;
+
+        if (!Ext.isObject(item)) {
+            item = me.menu.getComponent(item);
+        }
+        if (item) {
+            if (!me.rendered) {
+                me.text = me.getButtonText(item);
+                me.iconCls = item.iconCls;
+            } else {
+                me.setText(me.getButtonText(item));
+                me.setIconCls(item.iconCls);
+            }
+            me.activeItem = item;
+            if (!item.checked) {
+                item.setChecked(true, false);
+            }
+            if (me.forceIcon) {
+                me.setIconCls(me.forceIcon);
+            }
+            if (!suppressEvent) {
+                me.fireEvent('change', me, item);
+            }
+        }
+    },
+
+    
+    getActiveItem: function() {
+        return this.activeItem;
+    },
+
+    
+    initComponent: function() {
+        var me      = this,
+            checked = 0,
+            items,
+            i, iLen, item;
+
+        me.addEvents(
+            
+            "change"
+        );
+
+        if (me.changeHandler) {
+            me.on('change', me.changeHandler, me.scope || me);
+            delete me.changeHandler;
+        }
+
+        
+        
+        items = (me.menu.items || []).concat(me.items || []);
+        me.menu = Ext.applyIf({
+            cls: Ext.baseCSSPrefix + 'cycle-menu',
+            items: []
+        }, me.menu);
+
+        iLen = items.length;
+
+        
+        for (i = 0; i < iLen; i++) {
+            item = items[i];
+
+            item = Ext.applyIf({
+                group        : me.id,
+                itemIndex    : i,
+                checkHandler : me.checkHandler,
+                scope        : me,
+                checked      : item.checked || false
+            }, item);
+
+            me.menu.items.push(item);
+
+            if (item.checked) {
+                checked = i;
+            }
+        }
+
+        me.itemCount = me.menu.items.length;
+        me.callParent(arguments);
+        me.on('click', me.toggleSelected, me);
+        me.setActiveItem(checked, me);
+
+        
+        if (me.width && me.showText) {
+            me.addCls(Ext.baseCSSPrefix + 'cycle-fixed-width');
+        }
+    },
+
+    
+    checkHandler: function(item, pressed) {
+        if (pressed) {
+            this.setActiveItem(item);
+        }
+    },
+
+    
+    toggleSelected: function() {
+        var me = this,
+            m = me.menu,
+            checkItem;
+
+        checkItem = me.activeItem.next(':not([disabled])') || m.items.getAt(0);
+        checkItem.setChecked(true);
+    }
+});
+
+
+Ext.define('Ext.chart.Callout', {
+
+    
+
+    
+
+    constructor: function(config) {
+        if (config.callouts) {
+            config.callouts.styles = Ext.applyIf(config.callouts.styles || {}, {
+                color: "#000",
+                font: "11px Helvetica, sans-serif"
+            });
+            this.callouts = Ext.apply(this.callouts || {}, config.callouts);
+            this.calloutsArray = [];
+        }
+    },
+
+    renderCallouts: function() {
+        if (!this.callouts) {
+            return;
+        }
+
+        var me = this,
+            items = me.items,
+            animate = me.chart.animate,
+            config = me.callouts,
+            styles = config.styles,
+            group = me.calloutsArray,
+            store = me.chart.store,
+            len = store.getCount(),
+            ratio = items.length / len,
+            previouslyPlacedCallouts = [],
+            i,
+            count,
+            j,
+            p,
+            item,
+            label,
+            storeItem,
+            display;
+            
+        for (i = 0, count = 0; i < len; i++) {
+            for (j = 0; j < ratio; j++) {
+                item = items[count];
+                label = group[count];
+                storeItem = store.getAt(i);
+                
+                display = config.filter(storeItem);
+                
+                if (!display && !label) {
+                    count++;
+                    continue;               
+                }
+                
+                if (!label) {
+                    group[count] = label = me.onCreateCallout(storeItem, item, i, display, j, count);
+                }
+                for (p in label) {
+                    if (label[p] && label[p].setAttributes) {
+                        label[p].setAttributes(styles, true);
+                    }
+                }
+                if (!display) {
+                    for (p in label) {
+                        if (label[p]) {
+                            if (label[p].setAttributes) {
+                                label[p].setAttributes({
+                                    hidden: true
+                                }, true);
+                            } else if(label[p].setVisible) {
+                                label[p].setVisible(false);
+                            }
+                        }
+                    }
+                }
+                config.renderer(label, storeItem);
+                me.onPlaceCallout(label, storeItem, item, i, display, animate,
+                                  j, count, previouslyPlacedCallouts);
+                previouslyPlacedCallouts.push(label);
+                count++;
+            }
+        }
+        this.hideCallouts(count);
+    },
+
+    onCreateCallout: function(storeItem, item, i, display) {
+        var me = this,
+            group = me.calloutsGroup,
+            config = me.callouts,
+            styles = config.styles,
+            width = styles.width,
+            height = styles.height,
+            chart = me.chart,
+            surface = chart.surface,
+            calloutObj = {
+                
+                
+                lines: false
+            };
+
+        calloutObj.lines = surface.add(Ext.apply({},
+        {
+            type: 'path',
+            path: 'M0,0',
+            stroke: me.getLegendColor() || '#555'
+        },
+        styles));
+
+        if (config.items) {
+            calloutObj.panel = new Ext.Panel({
+                style: "position: absolute;",    
+                width: width,
+                height: height,
+                items: config.items,
+                renderTo: chart.el
+            });
+        }
+
+        return calloutObj;
+    },
+
+    hideCallouts: function(index) {
+        var calloutsArray = this.calloutsArray,
+            len = calloutsArray.length,
+            co,
+            p;
+        while (len-->index) {
+            co = calloutsArray[len];
+            for (p in co) {
+                if (co[p]) {
+                    co[p].hide(true);
+                }
+            }
+        }
+    }
+});
+
+
+
+Ext.define('Ext.layout.component.Draw', {
+
+    
+
+    alias: 'layout.draw',
+
+    extend: 'Ext.layout.component.Auto',
+
+    
+
+    type: 'draw',
+    
+    measureContentWidth : function (ownerContext) {
+        var target = ownerContext.target,
+            paddingInfo = ownerContext.getPaddingInfo(),
+            bbox = this.getBBox(ownerContext);
+            
+        if (!target.viewBox) {
+            if (target.autoSize) {
+                return bbox.width + paddingInfo.width;
+            } else {
+                return bbox.x + bbox.width + paddingInfo.width;
+            }
+        } else {
+            if (ownerContext.heightModel.shrinkWrap) {
+                return paddingInfo.width;
+            } else {
+                return bbox.width / bbox.height * (ownerContext.getProp('contentHeight') - paddingInfo.height) + paddingInfo.width;
+            }
+        }
+    },
+    
+    measureContentHeight : function (ownerContext) {
+        var target = ownerContext.target,
+            paddingInfo = ownerContext.getPaddingInfo(),
+            bbox = this.getBBox(ownerContext);
+            
+        if (!ownerContext.target.viewBox) {
+            if (target.autoSize) {
+                return bbox.height + paddingInfo.height;
+            } else {
+                return bbox.y + bbox.height + paddingInfo.height;
+            }
+        } else {
+            if (ownerContext.widthModel.shrinkWrap) {
+                return paddingInfo.height;
+            } else {
+                return bbox.height / bbox.width * (ownerContext.getProp('contentWidth') - paddingInfo.width) + paddingInfo.height;
+            }
+        }
+    },
+    
+    getBBox: function(ownerContext) {
+        var bbox = ownerContext.surfaceBBox;
+        if (!bbox) {
+            bbox = ownerContext.target.surface.items.getBBox();
+            
+            if (bbox.width === -Infinity && bbox.height === -Infinity) {
+                bbox.width = bbox.height = bbox.x = bbox.y = 0;
+            }
+            ownerContext.surfaceBBox = bbox;
+        }
+        return bbox;
+    },
+
+    publishInnerWidth: function (ownerContext, width) {
+        ownerContext.setContentWidth(width - ownerContext.getFrameInfo().width, true);
+    },
+    
+    publishInnerHeight: function (ownerContext, height) {
+        ownerContext.setContentHeight(height - ownerContext.getFrameInfo().height, true);
+    },
+    
+    finishedLayout: function (ownerContext) {
+        
+        var props = ownerContext.props,
+            paddingInfo = ownerContext.getPaddingInfo();
+
+        
+        
+        this.owner.setSurfaceSize(props.contentWidth - paddingInfo.width, props.contentHeight - paddingInfo.height);
+        
+        
+        this.callParent(arguments);
+    }
+});
+
+
+Ext.define('Ext.draw.CompositeSprite', {
+
+    
+
+    extend: 'Ext.util.MixedCollection',
+    mixins: {
+        animate: 'Ext.util.Animate'
+    },
+    autoDestroy: false,
+    
+    
+    isCompositeSprite: true,
+    constructor: function(config) {
+        var me = this;
+        
+        config = config || {};
+        Ext.apply(me, config);
+
+        me.addEvents(
+            
+            'mousedown',
+            
+            'mouseup',
+            
+            'mouseover',
+            
+            'mouseout',
+            
+            'click'
+        );
+        me.id = Ext.id(null, 'ext-sprite-group-');
+        me.callParent();
+    },
+
+    
+    onClick: function(e) {
+        this.fireEvent('click', e);
+    },
+
+    
+    onMouseUp: function(e) {
+        this.fireEvent('mouseup', e);
+    },
+
+    
+    onMouseDown: function(e) {
+        this.fireEvent('mousedown', e);
+    },
+
+    
+    onMouseOver: function(e) {
+        this.fireEvent('mouseover', e);
+    },
+
+    
+    onMouseOut: function(e) {
+        this.fireEvent('mouseout', e);
+    },
+
+    attachEvents: function(o) {
+        var me = this;
+        
+        o.on({
+            scope: me,
+            mousedown: me.onMouseDown,
+            mouseup: me.onMouseUp,
+            mouseover: me.onMouseOver,
+            mouseout: me.onMouseOut,
+            click: me.onClick
+        });
+    },
+
+    
+    add: function(key, o) {
+        var result = this.callParent(arguments);
+        this.attachEvents(result);
+        return result;
+    },
+
+    insert: function(index, key, o) {
+        return this.callParent(arguments);
+    },
+
+    
+    remove: function(o) {
+        var me = this;
+        
+        o.un({
+            scope: me,
+            mousedown: me.onMouseDown,
+            mouseup: me.onMouseUp,
+            mouseover: me.onMouseOver,
+            mouseout: me.onMouseOut,
+            click: me.onClick
+        });
+        return me.callParent(arguments);
+    },
+    
+    
+    getBBox: function() {
+        var i = 0,
+            sprite,
+            bb,
+            items = this.items,
+            len = this.length,
+            infinity = Infinity,
+            minX = infinity,
+            maxHeight = -infinity,
+            minY = infinity,
+            maxWidth = -infinity,
+            maxWidthBBox, maxHeightBBox;
+        
+        for (; i < len; i++) {
+            sprite = items[i];
+            if (sprite.el && ! sprite.bboxExcluded) {
+                bb = sprite.getBBox();
+                minX = Math.min(minX, bb.x);
+                minY = Math.min(minY, bb.y);
+                maxHeight = Math.max(maxHeight, bb.height + bb.y);
+                maxWidth = Math.max(maxWidth, bb.width + bb.x);
+            }
+        }
+        
+        return {
+            x: minX,
+            y: minY,
+            height: maxHeight - minY,
+            width: maxWidth - minX
+        };
+    },
+
+    
+    setAttributes: function(attrs, redraw) {
+        var i = 0,
+            items = this.items,
+            len = this.length;
+            
+        for (; i < len; i++) {
+            items[i].setAttributes(attrs, redraw);
+        }
+        return this;
+    },
+
+    
+    hide: function(redraw) {
+        var i = 0,
+            items = this.items,
+            len = this.length;
+            
+        for (; i < len; i++) {
+            items[i].hide(redraw);
+        }
+        return this;
+    },
+
+    
+    show: function(redraw) {
+        var i = 0,
+            items = this.items,
+            len = this.length;
+            
+        for (; i < len; i++) {
+            items[i].show(redraw);
+        }
+        return this;
+    },
+
+    
+    redraw: function() {
+        var me = this,
+            i = 0,
+            items = me.items,
+            surface = me.getSurface(),
+            len = me.length;
+        
+        if (surface) {
+            for (; i < len; i++) {
+                surface.renderItem(items[i]);
+            }
+        }
+        return me;
+    },
+
+    
+    setStyle: function(obj) {
+        var i = 0,
+            items = this.items,
+            len = this.length,
+            item, el;
+            
+        for (; i < len; i++) {
+            item = items[i];
+            el = item.el;
+            if (el) {
+                el.setStyle(obj);
+            }
+        }
+    },
+
+    
+    addCls: function(obj) {
+        var i = 0,
+            items = this.items,
+            surface = this.getSurface(),
+            len = this.length;
+        
+        if (surface) {
+            for (; i < len; i++) {
+                surface.addCls(items[i], obj);
+            }
+        }
+    },
+
+    
+    removeCls: function(obj) {
+        var i = 0,
+            items = this.items,
+            surface = this.getSurface(),
+            len = this.length;
+        
+        if (surface) {
+            for (; i < len; i++) {
+                surface.removeCls(items[i], obj);
+            }
+        }
+    },
+    
+    
+    getSurface: function(){
+        var first = this.first();
+        if (first) {
+            return first.surface;
+        }
+        return null;
+    },
+    
+    
+    destroy: function(){
+        var me = this,
+            surface = me.getSurface(),
+            destroySprites = me.autoDestroy,
+            item;
+            
+        if (surface) {
+            while (me.getCount() > 0) {
+                item = me.first();
+                me.remove(item);
+                surface.remove(item, destroySprites);
+            }
+        }
+        me.clearListeners();
+    }
+});
+
+
+Ext.define('Ext.draw.Surface', {
+
+    
+
+    mixins: {
+        observable: 'Ext.util.Observable'
+    },
+
+    requires: ['Ext.draw.CompositeSprite'],
+    uses: ['Ext.draw.engine.Svg', 'Ext.draw.engine.Vml', 'Ext.draw.engine.SvgExporter', 'Ext.draw.engine.ImageExporter'],
+
+    separatorRe: /[, ]+/,
+
+    statics: {
+        
+        create: function(config, enginePriority) {
+            enginePriority = enginePriority || ['Svg', 'Vml'];
+
+            var i = 0,
+                len = enginePriority.length,
+                surfaceClass;
+
+            for (; i < len; i++) {
+                if (Ext.supports[enginePriority[i]] !== false) {
+                    return Ext.create('Ext.draw.engine.' + enginePriority[i], config);
+                }
+            }
+            return false;
+        },
+        
+        
+        save: function(surface, config) {
+            config = config || {};
+            var exportTypes = {
+                    'image/png': 'Image',
+                    'image/jpeg': 'Image',
+                    'image/svg+xml': 'Svg'
+                },
+                prefix = exportTypes[config.type] || 'Svg',
+                exporter = Ext.draw.engine[prefix + 'Exporter'];           
+
+            return exporter.generate(surface, config);
+            
+        }
+    },
+
+    
+
+    
+    availableAttrs: {
+        blur: 0,
+        "clip-rect": "0 0 1e9 1e9",
+        cursor: "default",
+        cx: 0,
+        cy: 0,
+        'dominant-baseline': 'auto',
+        fill: "none",
+        "fill-opacity": 1,
+        font: '10px "Arial"',
+        "font-family": '"Arial"',
+        "font-size": "10",
+        "font-style": "normal",
+        "font-weight": 400,
+        gradient: "",
+        height: 0,
+        hidden: false,
+        href: "http://sencha.com/",
+        opacity: 1,
+        path: "M0,0",
+        radius: 0,
+        rx: 0,
+        ry: 0,
+        scale: "1 1",
+        src: "",
+        stroke: "none",
+        "stroke-dasharray": "",
+        "stroke-linecap": "butt",
+        "stroke-linejoin": "butt",
+        "stroke-miterlimit": 0,
+        "stroke-opacity": 1,
+        "stroke-width": 1,
+        target: "_blank",
+        text: "",
+        "text-anchor": "middle",
+        title: "Ext Draw",
+        width: 0,
+        x: 0,
+        y: 0,
+        zIndex: 0
+    },
+
+    
+    
+
+    container: undefined,
+    height: 352,
+    width: 512,
+    x: 0,
+    y: 0,
+
+    
+
+    
+    orderSpritesByZIndex: true,
+
+
+    
+    constructor: function(config) {
+        var me = this;
+        config = config || {};
+        Ext.apply(me, config);
+
+        me.domRef = Ext.getDoc().dom;
+
+        me.customAttributes = {};
+
+        me.addEvents(
+            
+            'mousedown',
+            
+            'mouseup',
+            
+            'mouseover',
+            
+            'mouseout',
+            
+            'mousemove',
+            
+            'mouseenter',
+            
+            'mouseleave',
+            
+            'click',
+            
+            'dblclick'
+        );
+
+        me.mixins.observable.constructor.call(me);
+
+        me.getId();
+        me.initGradients();
+        me.initItems();
+        if (me.renderTo) {
+            me.render(me.renderTo);
+            delete me.renderTo;
+        }
+        me.initBackground(config.background);
+    },
+
+    
+    
+    initSurface: Ext.emptyFn,
+
+    
+    
+    renderItem: Ext.emptyFn,
+
+    
+    renderItems: Ext.emptyFn,
+
+    
+    setViewBox: function (x, y, width, height) {
+        if (isFinite(x) && isFinite(y) && isFinite(width) && isFinite(height)) {
+            this.viewBox = {x: x, y: y, width: width, height: height};
+            this.applyViewBox();
+        }
+    },
+
+    
+    addCls: Ext.emptyFn,
+
+    
+    removeCls: Ext.emptyFn,
+
+    
+    setStyle: Ext.emptyFn,
+
+    
+    initGradients: function() {
+        if (this.hasOwnProperty('gradients')) {
+            var gradients = this.gradients,
+                gLen      = gradients.length,
+                fn        = this.addGradient,
+                g;
+
+            if (gradients) {
+                for (g = 0; g < gLen; g++) {
+                    if (fn.call(this, gradients[g], g, gLen) === false) {
+                        break;
+                    }
+                }
+            }
+        }
+    },
+
+    
+    initItems: function() {
+        var items = this.items;
+        this.items = new Ext.draw.CompositeSprite();
+        this.items.autoDestroy = true;
+        this.groups = new Ext.draw.CompositeSprite();
+        if (items) {
+            this.add(items);
+        }
+    },
+
+    
+    initBackground: function(config) {
+        var me = this,
+            width = me.width,
+            height = me.height,
+            gradientId, gradient, backgroundSprite;
+        if (Ext.isString(config)) {
+            config = {
+                fill : config
+            };
+        }
+        if (config) {
+            if (config.gradient) {
+                gradient = config.gradient;
+                gradientId = gradient.id;
+                me.addGradient(gradient);
+                me.background = me.add({
+                    type: 'rect',
+                    x: 0,
+                    y: 0,
+                    width: width,
+                    height: height,
+                    fill: 'url(#' + gradientId + ')',
+                    zIndex: -1
+                });
+            } else if (config.fill) {
+                me.background = me.add({
+                    type: 'rect',
+                    x: 0,
+                    y: 0,
+                    width: width,
+                    height: height,
+                    fill: config.fill,
+                    zIndex: -1
+                });
+            } else if (config.image) {
+                me.background = me.add({
+                    type: 'image',
+                    x: 0,
+                    y: 0,
+                    width: width,
+                    height: height,
+                    src: config.image,
+                    zIndex: -1
+                });
+            }
+            
+            me.background.bboxExcluded = true;
+        }
+    },
+
+    
+    setSize: function(w, h) {
+        this.applyViewBox();
+    },
+
+    
+    scrubAttrs: function(sprite) {
+        var i,
+            attrs = {},
+            exclude = {},
+            sattr = sprite.attr;
+        for (i in sattr) {
+            
+            if (this.translateAttrs.hasOwnProperty(i)) {
+                
+                attrs[this.translateAttrs[i]] = sattr[i];
+                exclude[this.translateAttrs[i]] = true;
+            }
+            else if (this.availableAttrs.hasOwnProperty(i) && !exclude[i]) {
+                
+                attrs[i] = sattr[i];
+            }
+        }
+        return attrs;
+    },
+
+    
+    onClick: function(e) {
+        this.processEvent('click', e);
+    },
+    
+    
+    onDblClick: function(e) {
+        this.processEvent('dblclick', e);
+    },
+
+    
+    onMouseUp: function(e) {
+        this.processEvent('mouseup', e);
+    },
+
+    
+    onMouseDown: function(e) {
+        this.processEvent('mousedown', e);
+    },
+
+    
+    onMouseOver: function(e) {
+        this.processEvent('mouseover', e);
+    },
+
+    
+    onMouseOut: function(e) {
+        this.processEvent('mouseout', e);
+    },
+
+    
+    onMouseMove: function(e) {
+        this.fireEvent('mousemove', e);
+    },
+
+    
+    onMouseEnter: Ext.emptyFn,
+
+    
+    onMouseLeave: Ext.emptyFn,
+
+    
+    addGradient: Ext.emptyFn,
+
+    
+    add: function() {
+        var args = Array.prototype.slice.call(arguments),
+            sprite,
+            index,
+            hasMultipleArgs = args.length > 1,
+            items,
+            results,
+            i,
+            ln,
+            item;
+            
+        if (hasMultipleArgs || Ext.isArray(args[0])) {
+            items = hasMultipleArgs ? args : args[0];
+            results = [];
+
+            for (i = 0, ln = items.length; i < ln; i++) {
+                item = items[i];
+                item = this.add(item);
+                results.push(item);
+            }
+
+            return results;
+        }
+        sprite = this.prepareItems(args[0], true)[0];
+        this.insertByZIndex(sprite);
+        this.onAdd(sprite);
+        return sprite;
+    },
+
+    
+    insertByZIndex: function(sprite) {
+        var me = this,
+            sprites = me.items.items,
+            len = sprites.length,
+            ceil = Math.ceil,
+            zIndex = sprite.attr.zIndex,
+            idx = len,
+            high = idx - 1,
+            low = 0,
+            otherZIndex;
+
+        if (me.orderSpritesByZIndex && len && zIndex < sprites[high].attr.zIndex) {
+            
+            while (low <= high) {
+                idx = ceil((low + high) / 2);
+                otherZIndex = sprites[idx].attr.zIndex;
+                if (otherZIndex > zIndex) {
+                    high = idx - 1;
+                }
+                else if (otherZIndex < zIndex) {
+                    low = idx + 1;
+                }
+                else {
+                    break;
+                }
+            }
+            
+            while (idx < len && sprites[idx].attr.zIndex <= zIndex) {
+                idx++;
+            }
+        }
+
+        me.items.insert(idx, sprite);
+        return idx;
+    },
+
+    onAdd: function(sprite) {
+        var group = sprite.group,
+            draggable = sprite.draggable,
+            groups, ln, i;
+        if (group) {
+            groups = [].concat(group);
+            ln = groups.length;
+            for (i = 0; i < ln; i++) {
+                group = groups[i];
+                this.getGroup(group).add(sprite);
+            }
+            delete sprite.group;
+        }
+        if (draggable) {
+            sprite.initDraggable();
+        }
+    },
+
+    
+    remove: function(sprite, destroySprite) {
+        if (sprite) {
+            this.items.remove(sprite);
+
+            var groups = [].concat(this.groups.items),
+                gLen   = groups.length,
+                g;
+
+            for (g = 0; g < gLen; g++) {
+                groups[g].remove(sprite);
+            }
+
+            sprite.onRemove();
+            if (destroySprite === true) {
+                sprite.destroy();
+            }
+        }
+    },
+
+    
+    removeAll: function(destroySprites) {
+        var items = this.items.items,
+            ln = items.length,
+            i;
+        for (i = ln - 1; i > -1; i--) {
+            this.remove(items[i], destroySprites);
+        }
+    },
+
+    onRemove: Ext.emptyFn,
+
+    onDestroy: Ext.emptyFn,
+
+    
+    applyViewBox: function() {
+        var me = this,
+            viewBox = me.viewBox,
+            width = me.width || 1, 
+            height = me.height || 1,
+            viewBoxX, viewBoxY, viewBoxWidth, viewBoxHeight,
+            relativeHeight, relativeWidth, size;
+
+        if (viewBox && (width || height)) {
+            viewBoxX = viewBox.x;
+            viewBoxY = viewBox.y;
+            viewBoxWidth = viewBox.width;
+            viewBoxHeight = viewBox.height;
+            relativeHeight = height / viewBoxHeight;
+            relativeWidth = width / viewBoxWidth;
+            size = Math.min(relativeWidth, relativeHeight);
+
+            if (viewBoxWidth * size < width) {
+                viewBoxX -= (width - viewBoxWidth * size) / 2 / size;
+            }
+            if (viewBoxHeight * size < height) {
+                viewBoxY -= (height - viewBoxHeight * size) / 2 / size;
+            }
+
+            me.viewBoxShift = {
+                dx: -viewBoxX,
+                dy: -viewBoxY,
+                scale: size
+            };
+            
+            if (me.background) {
+                me.background.setAttributes(Ext.apply({}, {
+                    x: viewBoxX,
+                    y: viewBoxY,
+                    width: width / size,
+                    height: height / size
+                }, { hidden: false }), true);
+            }
+        } else {
+            if (me.background && width && height) {
+                me.background.setAttributes(Ext.apply({x: 0, y: 0, width: width, height: height}, { hidden: false }), true);
+            }
+        }
+    },
+
+
+    getBBox: function (sprite, isWithoutTransform) {
+        var realPath = this["getPath" + sprite.type](sprite);
+        if (isWithoutTransform) {
+            sprite.bbox.plain = sprite.bbox.plain || Ext.draw.Draw.pathDimensions(realPath);
+            return sprite.bbox.plain;
+        }
+        if (sprite.dirtyTransform) {
+            this.applyTransformations(sprite, true);
+        }
+        sprite.bbox.transform = sprite.bbox.transform || Ext.draw.Draw.pathDimensions(Ext.draw.Draw.mapPath(realPath, sprite.matrix));
+        return sprite.bbox.transform;
+    },
+    
+    transformToViewBox: function (x, y) {
+        if (this.viewBoxShift) {
+            var me = this, shift = me.viewBoxShift;
+            return [x / shift.scale - shift.dx, y / shift.scale - shift.dy];
+        } else {
+            return [x, y];
+        }
+    },
+
+    
+    applyTransformations: function(sprite, onlyMatrix) {
+        if (sprite.type == 'text') {
+            
+            sprite.bbox.transform = 0;
+            this.transform(sprite, false);
+        }
+
+
+        sprite.dirtyTransform = false;
+        
+        var me = this,
+            attr = sprite.attr;
+
+        if (attr.translation.x != null || attr.translation.y != null) {
+            me.translate(sprite);
+        }
+        if (attr.scaling.x != null || attr.scaling.y != null) {
+            me.scale(sprite);
+        }
+        if (attr.rotation.degrees != null) {
+            me.rotate(sprite);
+        }
+        
+        sprite.bbox.transform = 0;
+        this.transform(sprite, onlyMatrix);
+        sprite.transformations = [];
+    },
+
+    
+    rotate: function (sprite) {
+        var bbox,
+            deg = sprite.attr.rotation.degrees,
+            centerX = sprite.attr.rotation.x,
+            centerY = sprite.attr.rotation.y;
+        if (!Ext.isNumber(centerX) || !Ext.isNumber(centerY)) {
+            bbox = this.getBBox(sprite, true);
+            centerX = !Ext.isNumber(centerX) ? bbox.x + bbox.width / 2 : centerX;
+            centerY = !Ext.isNumber(centerY) ? bbox.y + bbox.height / 2 : centerY;
+        }
+        sprite.transformations.push({
+            type: "rotate",
+            degrees: deg,
+            x: centerX,
+            y: centerY
+        });
+    },
+
+    
+    translate: function(sprite) {
+        var x = sprite.attr.translation.x || 0,
+            y = sprite.attr.translation.y || 0;
+        sprite.transformations.push({
+            type: "translate",
+            x: x,
+            y: y
+        });
+    },
+
+    
+    scale: function(sprite) {
+        var bbox,
+            x = sprite.attr.scaling.x || 1,
+            y = sprite.attr.scaling.y || 1,
+            centerX = sprite.attr.scaling.centerX,
+            centerY = sprite.attr.scaling.centerY;
+
+        if (!Ext.isNumber(centerX) || !Ext.isNumber(centerY)) {
+            bbox = this.getBBox(sprite, true);
+            centerX = !Ext.isNumber(centerX) ? bbox.x + bbox.width / 2 : centerX;
+            centerY = !Ext.isNumber(centerY) ? bbox.y + bbox.height / 2 : centerY;
+        }
+        sprite.transformations.push({
+            type: "scale",
+            x: x,
+            y: y,
+            centerX: centerX,
+            centerY: centerY
+        });
+    },
+
+    
+    rectPath: function (x, y, w, h, r) {
+        if (r) {
+            return [["M", x + r, y], ["l", w - r * 2, 0], ["a", r, r, 0, 0, 1, r, r], ["l", 0, h - r * 2], ["a", r, r, 0, 0, 1, -r, r], ["l", r * 2 - w, 0], ["a", r, r, 0, 0, 1, -r, -r], ["l", 0, r * 2 - h], ["a", r, r, 0, 0, 1, r, -r], ["z"]];
+        }
+        return [["M", x, y], ["l", w, 0], ["l", 0, h], ["l", -w, 0], ["z"]];
+    },
+
+    
+    ellipsePath: function (x, y, rx, ry) {
+        if (ry == null) {
+            ry = rx;
+        }
+        return [["M", x, y], ["m", 0, -ry], ["a", rx, ry, 0, 1, 1, 0, 2 * ry], ["a", rx, ry, 0, 1, 1, 0, -2 * ry], ["z"]];
+    },
+
+    
+    getPathpath: function (el) {
+        return el.attr.path;
+    },
+
+    
+    getPathcircle: function (el) {
+        var a = el.attr;
+        return this.ellipsePath(a.x, a.y, a.radius, a.radius);
+    },
+
+    
+    getPathellipse: function (el) {
+        var a = el.attr;
+        return this.ellipsePath(a.x, a.y,
+                                a.radiusX || (a.width / 2) || 0,
+                                a.radiusY || (a.height / 2) || 0);
+    },
+
+    
+    getPathrect: function (el) {
+        var a = el.attr;
+        return this.rectPath(a.x || 0, a.y || 0, a.width || 0, a.height || 0, a.r || 0);
+    },
+
+    
+    getPathimage: function (el) {
+        var a = el.attr;
+        return this.rectPath(a.x || 0, a.y || 0, a.width, a.height);
+    },
+
+    
+    getPathtext: function (el) {
+        var bbox = this.getBBoxText(el);
+        return this.rectPath(bbox.x, bbox.y, bbox.width, bbox.height);
+    },
+
+    createGroup: function(id) {
+        var group = this.groups.get(id);
+        if (!group) {
+            group = new Ext.draw.CompositeSprite({
+                surface: this
+            });
+            group.id = id || Ext.id(null, 'ext-surface-group-');
+            this.groups.add(group);
+        }
+        return group;
+    },
+
+    
+    getGroup: function(id) {
+        var group;
+        if (typeof id == "string") {
+            group = this.groups.get(id);
+            if (!group) {
+                group = this.createGroup(id);
+            }
+        } else {
+            group = id;
+        }
+        return group;
+    },
+
+    
+    prepareItems: function(items, applyDefaults) {
+        items = [].concat(items);
+        
+        var item, i, ln;
+        for (i = 0, ln = items.length; i < ln; i++) {
+            item = items[i];
+            if (!(item instanceof Ext.draw.Sprite)) {
+                
+                item.surface = this;
+                items[i] = this.createItem(item);
+            } else {
+                item.surface = this;
+            }
+        }
+        return items;
+    },
+
+    
+    setText: Ext.emptyFn,
+
+    
+    
+    createItem: Ext.emptyFn,
+
+    
+    getId: function() {
+        return this.id || (this.id = Ext.id(null, 'ext-surface-'));
+    },
+
+    
+    destroy: function() {
+        var me = this;
+        delete me.domRef;
+        if (me.background) {
+            me.background.destroy();
+        }
+        me.removeAll(true);
+        Ext.destroy(me.groups.items);
+    }
+});
+
+
+Ext.define('Ext.draw.Component', {
+
+    
+
+    alias: 'widget.draw',
+
+    extend: 'Ext.Component',
+
+    requires: [
+        'Ext.draw.Surface',
+        'Ext.layout.component.Draw'
+    ],
+
+    
+
+    
+    enginePriority: ['Svg', 'Vml'],
+
+    baseCls: Ext.baseCSSPrefix + 'surface',
+
+    componentLayout: 'draw',
+
+    
+    viewBox: true,
+
+    shrinkWrap: 3,
+    
+    
+    autoSize: false,
+
+    
+
+    
+
+    
+
+    initComponent: function() {
+        this.callParent(arguments);
+
+        this.addEvents(
+            
+            'mousedown',
+            
+            'mouseup',
+            
+            'mousemove',
+            
+            'mouseenter',
+            
+            'mouseleave',
+            
+            'click',
+            
+            'dblclick'
+        );
+    },
+
+    
+    onRender: function() {
+        var me = this,
+            viewBox = me.viewBox,
+            autoSize = me.autoSize,
+            bbox, items, width, height, x, y;
+        me.callParent(arguments);
+
+        if (me.createSurface() !== false) {
+            items = me.surface.items;
+
+            if (viewBox || autoSize) {
+                bbox = items.getBBox();
+                width = bbox.width;
+                height = bbox.height;
+                x = bbox.x;
+                y = bbox.y;
+                if (me.viewBox) {
+                    me.surface.setViewBox(x, y, width, height);
+                } else {
+                    me.autoSizeSurface();
+                }
+            }
+        }
+    },
+
+    
+    autoSizeSurface: function() {
+        var bbox = this.surface.items.getBBox();
+        this.setSurfaceSize(bbox.width, bbox.height);
+    },
+
+    setSurfaceSize: function (width, height) {
+        this.surface.setSize(width, height);
+        if (this.autoSize) {
+            var bbox = this.surface.items.getBBox();
+            this.surface.setViewBox(bbox.x, bbox.y - (+Ext.isOpera), width, height);
+        }
+    },
+    
+    
+    createSurface: function() {
+        var me = this,
+            cfg = Ext.applyIf({
+                renderTo: me.el,
+                height: me.height,
+                width: me.width,
+                items: me.items
+            }, me.initialConfig), surface;
+
+        
+        delete cfg.listeners;
+        surface = Ext.draw.Surface.create(cfg);
+        if (!surface) {
+            
+            return false;
+        }
+        me.surface = surface;
+
+
+        function refire(eventName) {
+            return function(e) {
+                me.fireEvent(eventName, e);
+            };
+        }
+
+        surface.on({
+            scope: me,
+            mouseup: refire('mouseup'),
+            mousedown: refire('mousedown'),
+            mousemove: refire('mousemove'),
+            mouseenter: refire('mouseenter'),
+            mouseleave: refire('mouseleave'),
+            click: refire('click'),
+            dblclick: refire('dblclick')
+        });
+    },
+
+
+    
+    onDestroy: function() {
+        Ext.destroy(this.surface);
+        this.callParent(arguments);
+    }
+
+});
+
+
+Ext.define('Ext.chart.Shape', {
+
+    
+
+    singleton: true,
+
+    
+
+    circle: function (surface, opts) {
+        return surface.add(Ext.apply({
+            type: 'circle',
+            x: opts.x,
+            y: opts.y,
+            stroke: null,
+            radius: opts.radius
+        }, opts));
+    },
+    line: function (surface, opts) {
+        return surface.add(Ext.apply({
+            type: 'rect',
+            x: opts.x - opts.radius,
+            y: opts.y - opts.radius,
+            height: 2 * opts.radius,
+            width: 2 * opts.radius / 5
+        }, opts));
+    },
+    square: function (surface, opts) {
+        return surface.add(Ext.applyIf({
+            type: 'rect',
+            x: opts.x - opts.radius,
+            y: opts.y - opts.radius,
+            height: 2 * opts.radius,
+            width: 2 * opts.radius,
+            radius: null
+        }, opts));
+    },
+    triangle: function (surface, opts) {
+        opts.radius *= 1.75;
+        return surface.add(Ext.apply({
+            type: 'path',
+            stroke: null,
+            path: "M".concat(opts.x, ",", opts.y, "m0-", opts.radius * 0.58, "l", opts.radius * 0.5, ",", opts.radius * 0.87, "-", opts.radius, ",0z")
+        }, opts));
+    },
+    diamond: function (surface, opts) {
+        var r = opts.radius;
+        r *= 1.5;
+        return surface.add(Ext.apply({
+            type: 'path',
+            stroke: null,
+            path: ["M", opts.x, opts.y - r, "l", r, r, -r, r, -r, -r, r, -r, "z"]
+        }, opts));
+    },
+    cross: function (surface, opts) {
+        var r = opts.radius;
+        r = r / 1.7;
+        return surface.add(Ext.apply({
+            type: 'path',
+            stroke: null,
+            path: "M".concat(opts.x - r, ",", opts.y, "l", [-r, -r, r, -r, r, r, r, -r, r, r, -r, r, r, r, -r, r, -r, -r, -r, r, -r, -r, "z"])
+        }, opts));
+    },
+    plus: function (surface, opts) {
+        var r = opts.radius / 1.3;
+        return surface.add(Ext.apply({
+            type: 'path',
+            stroke: null,
+            path: "M".concat(opts.x - r / 2, ",", opts.y - r / 2, "l", [0, -r, r, 0, 0, r, r, 0, 0, r, -r, 0, 0, r, -r, 0, 0, -r, -r, 0, 0, -r, "z"])
+        }, opts));
+    },
+    arrow: function (surface, opts) {
+        var r = opts.radius;
+        return surface.add(Ext.apply({
+            type: 'path',
+            path: "M".concat(opts.x - r * 0.7, ",", opts.y - r * 0.4, "l", [r * 0.6, 0, 0, -r * 0.4, r, r * 0.8, -r, r * 0.8, 0, -r * 0.4, -r * 0.6, 0], "z")
+        }, opts));
+    },
+    drop: function (surface, x, y, text, size, angle) {
+        size = size || 30;
+        angle = angle || 0;
+        surface.add({
+            type: 'path',
+            path: ['M', x, y, 'l', size, 0, 'A', size * 0.4, size * 0.4, 0, 1, 0, x + size * 0.7, y - size * 0.7, 'z'],
+            fill: '#000',
+            stroke: 'none',
+            rotate: {
+                degrees: 22.5 - angle,
+                x: x,
+                y: y
+            }
+        });
+        angle = (angle + 90) * Math.PI / 180;
+        surface.add({
+            type: 'text',
+            x: x + size * Math.sin(angle) - 10, 
+            y: y + size * Math.cos(angle) + 5,
+            text:  text,
+            'font-size': size * 12 / 40,
+            stroke: 'none',
+            fill: '#fff'
+        });
+    }
+});
+
+
+Ext.define('Ext.chart.LegendItem', {
+
+    
+
+    extend: 'Ext.draw.CompositeSprite',
+
+    requires: ['Ext.chart.Shape'],
+
+    
+
+    
+    x: 0,
+    y: 0,
+    zIndex: 500,
+
+    
+    boldRe: /bold\s\d{1,}.*/i,
+
+    constructor: function(config) {
+        this.callParent(arguments);
+        this.createLegend(config);
+    },
+
+    
+    createLegend: function(config) {
+        var me = this,
+            index = config.yFieldIndex,
+            series = me.series,
+            seriesType = series.type,
+            idx = me.yFieldIndex,
+            legend = me.legend,
+            surface = me.surface,
+            refX = legend.x + me.x,
+            refY = legend.y + me.y,
+            bbox, z = me.zIndex,
+            markerConfig, label, mask,
+            radius, toggle = false,
+            seriesStyle = Ext.apply(series.seriesStyle, series.style);
+
+        function getSeriesProp(name) {
+            var val = series[name];
+            return (Ext.isArray(val) ? val[idx] : val);
+        }
+        
+        label = me.add('label', surface.add({
+            type: 'text',
+            x: 20,
+            y: 0,
+            zIndex: (z || 0) + 2,
+            fill: legend.labelColor,
+            font: legend.labelFont,
+            text: getSeriesProp('title') || getSeriesProp('yField'),
+            style: {
+                'cursor': 'pointer'
+            }
+        }));
+
+        
+        if (seriesType === 'line' || seriesType === 'scatter') {
+            if(seriesType === 'line') {
+                me.add('line', surface.add({
+                    type: 'path',
+                    path: 'M0.5,0.5L16.5,0.5',
+                    zIndex: (z || 0) + 2,
+                    "stroke-width": series.lineWidth,
+                    "stroke-linejoin": "round",
+                    "stroke-dasharray": series.dash,
+                    stroke: seriesStyle.stroke || series.getLegendColor(index) || '#000',
+                    style: {
+                        cursor: 'pointer'
+                    }
+                }));
+            }
+            if (series.showMarkers || seriesType === 'scatter') {
+                markerConfig = Ext.apply(series.markerStyle, series.markerConfig || {}, {
+                    fill: series.getLegendColor(index)
+                });
+                me.add('marker', Ext.chart.Shape[markerConfig.type](surface, {
+                    fill: markerConfig.fill,
+                    x: 8.5,
+                    y: 0.5,
+                    zIndex: (z || 0) + 2,
+                    radius: markerConfig.radius || markerConfig.size,
+                    style: {
+                        cursor: 'pointer'
+                    }
+                }));
+            }
+        }
+        
+        else {
+            me.add('box', surface.add({
+                type: 'rect',
+                zIndex: (z || 0) + 2,
+                x: 0,
+                y: 0,
+                width: 12,
+                height: 12,
+                fill: series.getLegendColor(index),
+                style: {
+                    cursor: 'pointer'
+                }
+            }));
+        }
+        
+        me.setAttributes({
+            hidden: false
+        }, true);
+        
+        bbox = me.getBBox();
+        
+        mask = me.add('mask', surface.add({
+            type: 'rect',
+            x: bbox.x,
+            y: bbox.y,
+            width: bbox.width || 20,
+            height: bbox.height || 20,
+            zIndex: (z || 0) + 1,
+            fill: me.legend.boxFill,
+            style: {
+                'cursor': 'pointer'
+            }
+        }));
+
+        
+        me.on('mouseover', function() {
+            label.setStyle({
+                'font-weight': 'bold'
+            });
+            mask.setStyle({
+                'cursor': 'pointer'
+            });
+            series._index = index;
+            series.highlightItem();
+        }, me);
+
+        me.on('mouseout', function() {
+            label.setStyle({
+                'font-weight': legend.labelFont && me.boldRe.test(legend.labelFont) ? 'bold' : 'normal'
+            });
+            series._index = index;
+            series.unHighlightItem();
+        }, me);
+        
+        if (!series.visibleInLegend(index)) {
+            toggle = true;
+            label.setAttributes({
+               opacity: 0.5
+            }, true);
+        }
+
+        me.on('mousedown', function() {
+            if (!toggle) {
+                series.hideAll(index);
+                label.setAttributes({
+                    opacity: 0.5
+                }, true);
+            } else {
+                series.showAll(index);
+                label.setAttributes({
+                    opacity: 1
+                }, true);
+            }
+            toggle = !toggle;
+            me.legend.chart.redraw();
+        }, me);
+        me.updatePosition({x:0, y:0}); 
+    },
+
+    
+    updatePosition: function(relativeTo) {
+        var me = this,
+            items = me.items,
+            ln = items.length,
+            i = 0,
+            item;
+        if (!relativeTo) {
+            relativeTo = me.legend;
+        }
+        for (; i < ln; i++) {
+            item = items[i];
+            switch (item.type) {
+                case 'text':
+                    item.setAttributes({
+                        x: 20 + relativeTo.x + me.x,
+                        y: relativeTo.y + me.y
+                    }, true);
+                    break;
+                case 'rect':
+                    item.setAttributes({
+                        translate: {
+                            x: relativeTo.x + me.x,
+                            y: relativeTo.y + me.y - 6
+                        }
+                    }, true);
+                    break;
+                default:
+                    item.setAttributes({
+                        translate: {
+                            x: relativeTo.x + me.x,
+                            y: relativeTo.y + me.y
+                        }
+                    }, true);
+            }
+        }
+    }
+});
+
+
+Ext.define('Ext.chart.Legend', {
+
+    
+
+    requires: ['Ext.chart.LegendItem'],
+
+    
+
+    
+    visible: true,
+    
+    
+    update: true,
+
+    
+    position: 'bottom',
+
+    
+    x: 0,
+
+    
+    y: 0,
+
+    
+    labelColor: '#000',
+
+    
+    labelFont: '12px Helvetica, sans-serif',
+
+    
+    boxStroke: '#000',
+
+    
+    boxStrokeWidth: 1,
+
+    
+    boxFill: '#FFF',
+
+    
+    itemSpacing: 10,
+
+    
+    padding: 5,
+
+    
+    width: 0,
+    
+    height: 0,
+
+    
+    boxZIndex: 100,
+
+    
+    constructor: function(config) {
+        var me = this;
+        if (config) {
+            Ext.apply(me, config);
+        }
+        me.items = [];
+        
+        me.isVertical = ("left|right|float".indexOf(me.position) !== -1);
+
+        
+        me.origX = me.x;
+        me.origY = me.y;
+    },
+
+    
+    create: function() {
+        var me = this,
+            seriesItems = me.chart.series.items,
+            i, ln, series;
+
+        me.createBox();
+        
+        if (me.rebuild !== false) {
+            me.createItems();
+        }
+        
+        if (!me.created && me.isDisplayed()) {
+            me.created = true;
+
+            
+            for (i = 0, ln = seriesItems.length; i < ln; i++) {
+                series = seriesItems[i];
+                series.on('titlechange', function() {
+                    me.create();
+                    me.updatePosition();
+                });
+            }
+        }
+    },
+
+    
+    isDisplayed: function() {
+        return this.visible && this.chart.series.findIndex('showInLegend', true) !== -1;
+    },
+
+    
+    createItems: function() {
+        var me = this,
+            chart = me.chart,
+            seriesItems = chart.series.items,
+            ln, series,
+            surface = chart.surface,
+            items = me.items,
+            padding = me.padding,
+            itemSpacing = me.itemSpacing,
+            spacingOffset = 2,
+            maxWidth = 0,
+            maxHeight = 0,
+            totalWidth = 0,
+            totalHeight = 0,
+            vertical = me.isVertical,
+            math = Math,
+            mfloor = math.floor,
+            mmax = math.max,
+            index = 0,
+            i = 0,
+            len = items ? items.length : 0,
+            x, y, spacing, item, bbox, height, width,
+            fields, field, nFields, j;
+
+        
+        if (len) {
+            for (; i < len; i++) {
+                items[i].destroy();
+            }
+        }
+        
+        items.length = [];
+        
+        
+        for (i = 0, ln = seriesItems.length; i < ln; i++) {
+            series = seriesItems[i];
+            if (series.showInLegend) {
+                fields = [].concat(series.yField);
+                for (j = 0, nFields = fields.length; j < nFields; j++) {
+                    field = fields[j];
+                    item = new Ext.chart.LegendItem({
+                        legend: this,
+                        series: series,
+                        surface: chart.surface,
+                        yFieldIndex: j
+                    });
+                    bbox = item.getBBox();
+
+                    
+                    width = bbox.width;
+                    height = bbox.height;
+
+                    if (i + j === 0) {
+                        spacing = vertical ? padding + height / 2 : padding;
+                    }
+                    else {
+                        spacing = itemSpacing / (vertical ? 2 : 1);
+                    }
+                    
+                    item.x = mfloor(vertical ? padding : totalWidth + spacing);
+                    item.y = mfloor(vertical ? totalHeight + spacing : padding + height / 2);
+
+                    
+                    totalWidth += width + spacing;
+                    totalHeight += height + spacing;
+                    maxWidth = mmax(maxWidth, width);
+                    maxHeight = mmax(maxHeight, height);
+
+                    items.push(item);
+                }
+            }
+        }
+
+        
+        me.width = mfloor((vertical ? maxWidth : totalWidth) + padding * 2);
+        if (vertical && items.length === 1) {
+            spacingOffset = 1;
+        }
+        me.height = mfloor((vertical ? totalHeight - spacingOffset * spacing : maxHeight) + (padding * 2));
+        me.itemHeight = maxHeight;
+    },
+
+    
+    getBBox: function() {
+        var me = this;
+        return {
+            x: Math.round(me.x) - me.boxStrokeWidth / 2,
+            y: Math.round(me.y) - me.boxStrokeWidth / 2,
+            width: me.width,
+            height: me.height
+        };
+    },
+
+    
+    createBox: function() {
+        var me = this,
+            box, bbox;
+
+        if (me.boxSprite) {
+            me.boxSprite.destroy();
+        }
+
+        bbox = me.getBBox();
+        
+        
+        
+        
+        
+        if (isNaN(bbox.width) || isNaN(bbox.height)) {
+            me.boxSprite = false;
+            return;
+        }
+        
+        box = me.boxSprite = me.chart.surface.add(Ext.apply({
+            type: 'rect',
+            stroke: me.boxStroke,
+            "stroke-width": me.boxStrokeWidth,
+            fill: me.boxFill,
+            zIndex: me.boxZIndex
+        }, bbox));
+
+        box.redraw();
+    },
+
+    
+    updatePosition: function() {
+        var me = this,
+            items = me.items,
+            i, ln,
+            x, y,
+            legendWidth = me.width || 0,
+            legendHeight = me.height || 0,
+            padding = me.padding,
+            chart = me.chart,
+            chartBBox = chart.chartBBox,
+            insets = chart.insetPadding,
+            chartWidth = chartBBox.width - (insets * 2),
+            chartHeight = chartBBox.height - (insets * 2),
+            chartX = chartBBox.x + insets,
+            chartY = chartBBox.y + insets,
+            surface = chart.surface,
+            mfloor = Math.floor,
+            bbox;
+
+        if (me.isDisplayed()) {
+            
+            switch(me.position) {
+                case "left":
+                    x = insets;
+                    y = mfloor(chartY + chartHeight / 2 - legendHeight / 2);
+                    break;
+                case "right":
+                    x = mfloor(surface.width - legendWidth) - insets;
+                    y = mfloor(chartY + chartHeight / 2 - legendHeight / 2);
+                    break;
+                case "top":
+                    x = mfloor(chartX + chartWidth / 2 - legendWidth / 2);
+                    y = insets;
+                    break;
+                case "bottom":
+                    x = mfloor(chartX + chartWidth / 2 - legendWidth / 2);
+                    y = mfloor(surface.height - legendHeight) - insets;
+                    break;
+                default:
+                    x = mfloor(me.origX) + insets;
+                    y = mfloor(me.origY) + insets;
+            }
+            me.x = x;
+            me.y = y;
+
+            
+            for (i = 0, ln = items.length; i < ln; i++) {
+                items[i].updatePosition();
+            }
+
+            bbox = me.getBBox();
+
+            
+            
+            
+            
+            
+            if (isNaN(bbox.width) || isNaN(bbox.height)) {
+                if (me.boxSprite) {
+                    me.boxSprite.hide(true);
+                }
+            } else {
+                if (!me.boxSprite) {
+                    me.createBox();
+                }
+                
+                me.boxSprite.setAttributes(bbox, true);
+                me.boxSprite.show(true);
+            }
+        }
+    },
+    
+    
+    toggle: function(show) {
+      var me = this,
+          i = 0,
+          items = me.items,
+          len = items.length;
+
+      if (me.boxSprite) {
+          if (show) {
+              me.boxSprite.show(true);
+          } else {
+              me.boxSprite.hide(true);
+          }
+      }
+
+      for (; i < len; ++i) {
+          if (show) {
+            items[i].show(true);
+          } else {
+              items[i].hide(true);
+          }
+      }
+
+      me.visible = show;
+    }
+});
+
+
+Ext.define('Ext.chart.theme.Theme', {
+
+    
+
+    requires: ['Ext.draw.Color'],
+
+    
+
+    theme: 'Base',
+    themeAttrs: false,
+    
+    initTheme: function(theme) {
+        var me = this,
+            themes = Ext.chart.theme,
+            key, gradients;
+        if (theme) {
+            theme = theme.split(':');
+            for (key in themes) {
+                if (key == theme[0]) {
+                    gradients = theme[1] == 'gradients';
+                    me.themeAttrs = new themes[key]({
+                        useGradients: gradients
+                    });
+                    if (gradients) {
+                        me.gradients = me.themeAttrs.gradients;
+                    }
+                    if (me.themeAttrs.background) {
+                        me.background = me.themeAttrs.background;
+                    }
+                    return;
+                }
+            }
+        }
+    }
+}, 
+
+function() {
+   
+
+(function() {
+    Ext.chart.theme = function(config, base) {
+        config = config || {};
+        var i = 0, d = +new Date(), l, colors, color,
+            seriesThemes, markerThemes,
+            seriesTheme, markerTheme, 
+            key, gradients = [],
+            midColor, midL;
+        
+        if (config.baseColor) {
+            midColor = Ext.draw.Color.fromString(config.baseColor);
+            midL = midColor.getHSL()[2];
+            if (midL < 0.15) {
+                midColor = midColor.getLighter(0.3);
+            } else if (midL < 0.3) {
+                midColor = midColor.getLighter(0.15);
+            } else if (midL > 0.85) {
+                midColor = midColor.getDarker(0.3);
+            } else if (midL > 0.7) {
+                midColor = midColor.getDarker(0.15);
+            }
+            config.colors = [ midColor.getDarker(0.3).toString(),
+                              midColor.getDarker(0.15).toString(),
+                              midColor.toString(),
+                              midColor.getLighter(0.15).toString(),
+                              midColor.getLighter(0.3).toString()];
+
+            delete config.baseColor;
+        }
+        if (config.colors) {
+            colors = config.colors.slice();
+            markerThemes = base.markerThemes;
+            seriesThemes = base.seriesThemes;
+            l = colors.length;
+            base.colors = colors;
+            for (; i < l; i++) {
+                color = colors[i];
+                markerTheme = markerThemes[i] || {};
+                seriesTheme = seriesThemes[i] || {};
+                markerTheme.fill = seriesTheme.fill = markerTheme.stroke = seriesTheme.stroke = color;
+                markerThemes[i] = markerTheme;
+                seriesThemes[i] = seriesTheme;
+            }
+            base.markerThemes = markerThemes.slice(0, l);
+            base.seriesThemes = seriesThemes.slice(0, l);
+        
+        }
+        for (key in base) {
+            if (key in config) {
+                if (Ext.isObject(config[key]) && Ext.isObject(base[key])) {
+                    Ext.apply(base[key], config[key]);
+                } else {
+                    base[key] = config[key];
+                }
+            }
+        }
+        if (config.useGradients) {
+            colors = base.colors || (function () {
+                var ans = [];
+                for (i = 0, seriesThemes = base.seriesThemes, l = seriesThemes.length; i < l; i++) {
+                    ans.push(seriesThemes[i].fill || seriesThemes[i].stroke);
+                }
+                return ans;
+            }());
+            for (i = 0, l = colors.length; i < l; i++) {
+                midColor = Ext.draw.Color.fromString(colors[i]);
+                if (midColor) {
+                    color = midColor.getDarker(0.1).toString();
+                    midColor = midColor.toString();
+                    key = 'theme-' + midColor.substr(1) + '-' + color.substr(1) + '-' + d;
+                    gradients.push({
+                        id: key,
+                        angle: 45,
+                        stops: {
+                            0: {
+                                color: midColor.toString()
+                            },
+                            100: {
+                                color: color.toString()
+                            }
+                        }
+                    });
+                    colors[i] = 'url(#' + key + ')'; 
+                }
+            }
+            base.gradients = gradients;
+            base.colors = colors;
+        }
+        
+        Ext.apply(this, base);
+    };
+}());
+});
+
+
+Ext.define('Ext.chart.theme.Base', {
+
+    
+
+    requires: ['Ext.chart.theme.Theme'],
+
+    
+
+    constructor: function(config) {
+        Ext.chart.theme.call(this, config, {
+            background: false,
+            axis: {
+                stroke: '#444',
+                'stroke-width': 1
+            },
+            axisLabelTop: {
+                fill: '#444',
+                font: '12px Arial, Helvetica, sans-serif',
+                spacing: 2,
+                padding: 5,
+                renderer: function(v) { return v; }
+            },
+            axisLabelRight: {
+                fill: '#444',
+                font: '12px Arial, Helvetica, sans-serif',
+                spacing: 2,
+                padding: 5,
+                renderer: function(v) { return v; }
+            },
+            axisLabelBottom: {
+                fill: '#444',
+                font: '12px Arial, Helvetica, sans-serif',
+                spacing: 2,
+                padding: 5,
+                renderer: function(v) { return v; }
+            },
+            axisLabelLeft: {
+                fill: '#444',
+                font: '12px Arial, Helvetica, sans-serif',
+                spacing: 2,
+                padding: 5,
+                renderer: function(v) { return v; }
+            },
+            axisTitleTop: {
+                font: 'bold 18px Arial',
+                fill: '#444'
+            },
+            axisTitleRight: {
+                font: 'bold 18px Arial',
+                fill: '#444',
+                rotate: {
+                    x:0, y:0,
+                    degrees: 270
+                }
+            },
+            axisTitleBottom: {
+                font: 'bold 18px Arial',
+                fill: '#444'
+            },
+            axisTitleLeft: {
+                font: 'bold 18px Arial',
+                fill: '#444',
+                rotate: {
+                    x:0, y:0,
+                    degrees: 270
+                }
+            },
+            series: {
+                'stroke-width': 0
+            },
+            seriesLabel: {
+                font: '12px Arial',
+                fill: '#333'
+            },
+            marker: {
+                stroke: '#555',
+                radius: 3,
+                size: 3
+            },
+            colors: [ "#94ae0a", "#115fa6","#a61120", "#ff8809", "#ffd13e", "#a61187", "#24ad9a", "#7c7474", "#a66111"],
+            seriesThemes: [{
+                fill: "#115fa6"
+            }, {
+                fill: "#94ae0a"
+            }, {
+                fill: "#a61120"
+            }, {
+                fill: "#ff8809"
+            }, {
+                fill: "#ffd13e"
+            }, {
+                fill: "#a61187"
+            }, {
+                fill: "#24ad9a"
+            }, {
+                fill: "#7c7474"
+            }, {
+                fill: "#115fa6"
+            }, {
+                fill: "#94ae0a"
+            }, {
+                fill: "#a61120"
+            }, {
+                fill: "#ff8809"
+            }, {
+                fill: "#ffd13e"
+            }, {
+                fill: "#a61187"
+            }, {
+                fill: "#24ad9a"
+            }, {
+                fill: "#7c7474"
+            }, {
+                fill: "#a66111"
+            }],
+            markerThemes: [{
+                fill: "#115fa6",
+                type: 'circle' 
+            }, {
+                fill: "#94ae0a",
+                type: 'cross'
+            }, {
+                fill: "#115fa6",
+                type: 'plus' 
+            }, {
+                fill: "#94ae0a",
+                type: 'circle'
+            }, {
+                fill: "#a61120",
+                type: 'cross'
+            }]
+        });
+    }
+}, function() {
+    var palette = ['#b1da5a', '#4ce0e7', '#e84b67', '#da5abd', '#4d7fe6', '#fec935'],
+        names = ['Green', 'Sky', 'Red', 'Purple', 'Blue', 'Yellow'],
+        i = 0, j = 0, l = palette.length, themes = Ext.chart.theme,
+        categories = [['#f0a50a', '#c20024', '#2044ba', '#810065', '#7eae29'],
+                      ['#6d9824', '#87146e', '#2a9196', '#d39006', '#1e40ac'],
+                      ['#fbbc29', '#ce2e4e', '#7e0062', '#158b90', '#57880e'],
+                      ['#ef5773', '#fcbd2a', '#4f770d', '#1d3eaa', '#9b001f'],
+                      ['#7eae29', '#fdbe2a', '#910019', '#27b4bc', '#d74dbc'],
+                      ['#44dce1', '#0b2592', '#996e05', '#7fb325', '#b821a1']],
+        cats = categories.length;
+    
+    
+    for (; i < l; i++) {
+        themes[names[i]] = (function(color) {
+            return Ext.extend(themes.Base, {
+                constructor: function(config) {
+                    themes.Base.prototype.constructor.call(this, Ext.apply({
+                        baseColor: color
+                    }, config));
+                }
+            });
+        }(palette[i]));
+    }
+    
+    
+    for (i = 0; i < cats; i++) {
+        themes['Category' + (i + 1)] = (function(category) {
+            return Ext.extend(themes.Base, {
+                constructor: function(config) {
+                    themes.Base.prototype.constructor.call(this, Ext.apply({
+                        colors: category
+                    }, config));
+                }
+            });
+        }(categories[i]));
+    }
+});
+
+
+Ext.define('Ext.chart.MaskLayer', {
+    extend: 'Ext.Component',
+    
+    constructor: function(config) {
+        config = Ext.apply(config || {}, {
+            style: 'position:absolute;background-color:#888;cursor:move;opacity:0.6;border:1px solid #222;'
+        });
+        this.callParent([config]);    
+    },
+    
+    initComponent: function() {
+        var me = this;
+        me.callParent(arguments);
+        me.addEvents(
+            'mousedown',
+            'mouseup',
+            'mousemove',
+            'mouseenter',
+            'mouseleave'
+        );
+    },
+
+    initDraggable: function() {
+        this.callParent(arguments);
+        this.dd.onStart = function (e) {
+            var me = this,
+                comp = me.comp;
+    
+            
+            this.startPosition = comp.getPosition(true);
+    
+            
+            
+            if (comp.ghost && !comp.liveDrag) {
+                 me.proxy = comp.ghost();
+                 me.dragTarget = me.proxy.header.el;
+            }
+    
+            
+            if (me.constrain || me.constrainDelegate) {
+                me.constrainTo = me.calculateConstrainRegion();
+            }
+        };
+    }
+});
+
+
+Ext.define('Ext.chart.Mask', {
+    requires: [
+        'Ext.chart.MaskLayer'
+    ],
+    
+    
+
+    
+    constructor: function(config) {
+        var me = this,
+            resizeHandler;
+
+        me.addEvents('select');
+
+        if (config) {
+            Ext.apply(me, config);
+        }
+        if (me.enableMask) {
+            me.on('afterrender', function() {
+                
+                var comp = new Ext.chart.MaskLayer({
+                    renderTo: me.el,
+                    hidden: true
+                });
+                comp.el.on({
+                    'mousemove': function(e) {
+                        me.onMouseMove(e);
+                    },
+                    'mouseup': function(e) {
+                        me.resized(e);
+                    }
+                });
+                
+                resizeHandler = new Ext.resizer.Resizer({
+                    el: comp.el,
+                    handles: 'all',
+                    pinned: true
+                });
+                resizeHandler.on({
+                    'resize': function(e) {
+                        me.resized(e);    
+                    }    
+                });
+                comp.initDraggable();
+                me.maskType = me.mask;
+                me.mask = comp;
+                me.maskSprite = me.surface.add({
+                    type: 'path',
+                    path: ['M', 0, 0],
+                    zIndex: 1001,
+                    opacity: 0.7,
+                    hidden: true,
+                    stroke: '#444'
+                });
+            }, me, { single: true });
+        }
+    },
+    
+    resized: function(e) {
+        var me = this,
+            bbox = me.bbox || me.chartBBox,
+            x = bbox.x,
+            y = bbox.y,
+            width = bbox.width,
+            height = bbox.height,
+            box = me.mask.getBox(true),
+            max = Math.max,
+            min = Math.min,
+            staticX = box.x - x,
+            staticY = box.y - y;
+        
+        staticX = max(staticX, x);
+        staticY = max(staticY, y);
+        staticX = min(staticX, width);
+        staticY = min(staticY, height);
+        box.x = staticX;
+        box.y = staticY;
+        me.fireEvent('select', me, box);
+    },
+
+    onMouseUp: function(e) {
+        var me = this,
+            bbox = me.bbox || me.chartBBox,
+            sel = me.maskSelection;
+        me.maskMouseDown = false;
+        me.mouseDown = false;
+        if (me.mouseMoved) {
+            me.onMouseMove(e);
+            me.mouseMoved = false;
+            me.fireEvent('select', me, {
+                x: sel.x - bbox.x,
+                y: sel.y - bbox.y,
+                width: sel.width,
+                height: sel.height
+            });
+        }
+    },
+
+    onMouseDown: function(e) {
+        var me = this;
+        me.mouseDown = true;
+        me.mouseMoved = false;
+        me.maskMouseDown = {
+            x: e.getPageX() - me.el.getX(),
+            y: e.getPageY() - me.el.getY()
+        };
+    },
+
+    onMouseMove: function(e) {
+        var me = this,
+            mask = me.maskType,
+            bbox = me.bbox || me.chartBBox,
+            x = bbox.x,
+            y = bbox.y,
+            math = Math,
+            floor = math.floor,
+            abs = math.abs,
+            min = math.min,
+            max = math.max,
+            height = floor(y + bbox.height),
+            width = floor(x + bbox.width),
+            posX = e.getPageX(),
+            posY = e.getPageY(),
+            staticX = posX - me.el.getX(),
+            staticY = posY - me.el.getY(),
+            maskMouseDown = me.maskMouseDown,
+            path;
+        
+        me.mouseMoved = me.mouseDown;
+        staticX = max(staticX, x);
+        staticY = max(staticY, y);
+        staticX = min(staticX, width);
+        staticY = min(staticY, height);
+        if (maskMouseDown && me.mouseDown) {
+            if (mask == 'horizontal') {
+                staticY = y;
+                maskMouseDown.y = height;
+                posY = me.el.getY() + bbox.height + me.insetPadding;
+            }
+            else if (mask == 'vertical') {
+                staticX = x;
+                maskMouseDown.x = width;
+            }
+            width = maskMouseDown.x - staticX;
+            height = maskMouseDown.y - staticY;
+            path = ['M', staticX, staticY, 'l', width, 0, 0, height, -width, 0, 'z'];
+            me.maskSelection = {
+                x: width > 0 ? staticX : staticX + width,
+                y: height > 0 ? staticY : staticY + height,
+                width: abs(width),
+                height: abs(height)
+            };
+            me.mask.updateBox(me.maskSelection);
+            me.mask.show();
+            me.maskSprite.setAttributes({
+                hidden: true    
+            }, true);
+        }
+        else {
+            if (mask == 'horizontal') {
+                path = ['M', staticX, y, 'L', staticX, height];
+            }
+            else if (mask == 'vertical') {
+                path = ['M', x, staticY, 'L', width, staticY];
+            }
+            else {
+                path = ['M', staticX, y, 'L', staticX, height, 'M', x, staticY, 'L', width, staticY];
+            }
+            me.maskSprite.setAttributes({
+                path: path,
+                fill: me.maskMouseDown ? me.maskSprite.stroke : false,
+                'stroke-width': mask === true ? 1 : 3,
+                hidden: false
+            }, true);
+        }
+    },
+
+    onMouseLeave: function(e) {
+        var me = this;
+        me.mouseMoved = false;
+        me.mouseDown = false;
+        me.maskMouseDown = false;
+        me.mask.hide();
+        me.maskSprite.hide(true);
+    }
+});
+    
+
+
+Ext.define('Ext.chart.Navigation', {
+
+    constructor: function() {
+        this.originalStore = this.store;
+    },
+
+    
+    setZoom: function(zoomConfig) {
+        var me = this,
+            axes = me.axes,
+            axesItems = axes.items,
+            i, ln, axis,
+            bbox = me.chartBBox,
+            xScale = 1 / bbox.width,
+            yScale = 1 / bbox.height,
+            zoomer = {
+                x : zoomConfig.x * xScale,
+                y : zoomConfig.y * yScale,
+                width : zoomConfig.width * xScale,
+                height : zoomConfig.height * yScale
+            },
+            ends, from, to;
+        for (i = 0, ln = axesItems.length; i < ln; i++) {
+            axis = axesItems[i];
+            ends = axis.calcEnds();
+            if (axis.position == 'bottom' || axis.position == 'top') {
+                from = (ends.to - ends.from) * zoomer.x + ends.from;
+                to = (ends.to - ends.from) * zoomer.width + from;
+                axis.minimum = from;
+                axis.maximum = to;
+            } else {
+                to = (ends.to - ends.from) * (1 - zoomer.y) + ends.from;
+                from = to - (ends.to - ends.from) * zoomer.height;
+                axis.minimum = from;
+                axis.maximum = to;
+            }
+        }
+        me.redraw(false);
+    },
+
+    
+    restoreZoom: function() {
+        if (this.originalStore) {
+            this.store = this.substore = this.originalStore;
+            this.redraw(true);
+        }
+    }
+
+});
+
+
+Ext.define('Ext.chart.Chart', {
+
+    
+
+    alias: 'widget.chart',
+
+    extend: 'Ext.draw.Component',
+    
+    mixins: {
+        themeManager: 'Ext.chart.theme.Theme',
+        mask: 'Ext.chart.Mask',
+        navigation: 'Ext.chart.Navigation',
+        bindable: 'Ext.util.Bindable',
+        observable: 'Ext.util.Observable'
+    },
+
+    uses: [
+        'Ext.chart.series.Series'
+    ],
+    
+    requires: [
+        'Ext.util.MixedCollection',
+        'Ext.data.StoreManager',
+        'Ext.chart.Legend',
+        'Ext.chart.theme.Base',
+        'Ext.chart.theme.Theme',
+        'Ext.util.DelayedTask'
+    ],
+
+    
+
+    
+    viewBox: false,
+
+    
+
+    
+    animate: false,
+
+    
+    legend: false,
+
+    
+    insetPadding: 10,
+
+    
+    enginePriority: ['Svg', 'Vml'],
+
+    
+    background: false,
+
+    
+
+    
+
+    
+
+    
+
+    constructor: function(config) {
+        var me = this,
+            defaultAnim;
+
+        config = Ext.apply({}, config);
+        me.initTheme(config.theme || me.theme);
+        if (me.gradients) {
+            Ext.apply(config, { gradients: me.gradients });
+        }
+        if (me.background) {
+            Ext.apply(config, { background: me.background });
+        }
+        if (config.animate) {
+            defaultAnim = {
+                easing: 'ease',
+                duration: 500
+            };
+            if (Ext.isObject(config.animate)) {
+                config.animate = Ext.applyIf(config.animate, defaultAnim);
+            }
+            else {
+                config.animate = defaultAnim;
+            }
+        }
+
+        me.mixins.observable.constructor.call(me, config);
+        if (config.enableMask) {
+            me.mixins.mask.constructor.call(me);
+        }
+        me.mixins.navigation.constructor.call(me);
+        me.callParent([config]);
+    },
+    
+    getChartStore: function(){
+        return this.substore || this.store;
+    },
+
+    initComponent: function() {
+        var me = this,
+            axes,
+            series;
+        me.callParent();
+        me.addEvents(
+            'itemmousedown',
+            'itemmouseup',
+            'itemmouseover',
+            'itemmouseout',
+            'itemclick',
+            'itemdblclick',
+            'itemdragstart',
+            'itemdrag',
+            'itemdragend',
+            
+            'beforerefresh',
+            
+            'refresh'
+        );
+        Ext.applyIf(me, {
+            zoom: {
+                width: 1,
+                height: 1,
+                x: 0,
+                y: 0
+            }
+        });
+        me.maxGutter = [0, 0];
+        me.store = Ext.data.StoreManager.lookup(me.store);
+        axes = me.axes;
+        me.axes = new Ext.util.MixedCollection(false, function(a) { return a.position; });
+        if (axes) {
+            me.axes.addAll(axes);
+        }
+        series = me.series;
+        me.series = new Ext.util.MixedCollection(false, function(a) { return a.seriesId || (a.seriesId = Ext.id(null, 'ext-chart-series-')); });
+        if (series) {
+            me.series.addAll(series);
+        }
+        if (me.legend !== false) {
+            me.legend = new Ext.chart.Legend(Ext.applyIf({chart:me}, me.legend));
+        }
+
+        me.on({
+            mousemove: me.onMouseMove,
+            mouseleave: me.onMouseLeave,
+            mousedown: me.onMouseDown,
+            mouseup: me.onMouseUp,
+            click: me.onClick,
+            dblclick: me.onDblClick,
+            scope: me
+        });
+    },
+
+    
+    afterComponentLayout: function(width, height) {
+        var me = this;
+        if (Ext.isNumber(width) && Ext.isNumber(height)) {
+            if (width !== me.curWidth || height !== me.curHeight) {
+                me.curWidth = width;
+                me.curHeight = height;
+                me.redraw(true);
+            } else if (me.needsRedraw) {
+                delete me.needsRedraw;
+                me.redraw();
+            }
+        }
+        this.callParent(arguments);
+    },
+
+    
+    redraw: function(resize) {
+        var me = this,
+            seriesItems = me.series.items,
+            seriesLen = seriesItems.length,
+            axesItems = me.axes.items,
+            axesLen = axesItems.length,
+            i,
+            chartBBox = me.chartBBox = {
+                x: 0,
+                y: 0,
+                height: me.curHeight,
+                width: me.curWidth
+            },
+            legend = me.legend;
+        me.surface.setSize(chartBBox.width, chartBBox.height);
+        
+        for (i = 0; i < seriesLen; i++) {
+            me.initializeSeries(seriesItems[i],i);
+        }
+        for (i = 0; i < axesLen; i++) {
+            me.initializeAxis(axesItems[i]);
+        }
+        
+        
+        for (i = 0; i < axesLen; i++) {
+            axesItems[i].processView();
+        }
+        for (i = 0; i < axesLen; i++) {
+            axesItems[i].drawAxis(true);
+        }
+
+        
+        if (legend !== false && legend.visible) {
+            if (legend.update || !legend.created) {
+              legend.create();
+            }
+        }
+
+        
+        me.alignAxes();
+
+        
+        if (legend !== false && legend.visible) {
+            legend.updatePosition();
+        }
+
+        
+        me.getMaxGutter();
+
+        
+        me.resizing = !!resize;
+
+        for (i = 0; i < axesLen; i++) {
+            axesItems[i].drawAxis();
+        }
+        for (i = 0; i < seriesLen; i++) {
+            me.drawCharts(seriesItems[i]);
+        }
+        me.resizing = false;
+    },
+
+    
+    afterRender: function() {
+        var ref,
+            me = this;
+        this.callParent();
+
+        if (me.categoryNames) {
+            me.setCategoryNames(me.categoryNames);
+        }
+
+        if (me.tipRenderer) {
+            ref = me.getFunctionRef(me.tipRenderer);
+            me.setTipRenderer(ref.fn, ref.scope);
+        }
+        me.bindStore(me.store, true);
+        me.refresh();
+
+        if (me.surface.engine === 'Vml') {
+            me.on('added', me.onAddedVml, me);
+            me.mon(Ext.container.Container.hierarchyEventSource, 'added', me.onContainerAddedVml, me);
+        }
+    },
+
+    
+    
+    
+    
+    
+    onAddedVml: function() {
+        this.needsRedraw = true; 
+    },
+
+    onContainerAddedVml: function(container) {
+        if (this.isDescendantOf(container)) {
+            this.needsRedraw = true; 
+        }
+    },
+
+    
+    getEventXY: function(e) {
+        var me = this,
+            box = this.surface.getRegion(),
+            pageXY = e.getXY(),
+            x = pageXY[0] - box.left,
+            y = pageXY[1] - box.top;
+        return [x, y];
+    },
+    
+    onClick: function(e) {
+        this.handleClick('itemclick', e);
+    },
+    
+    onDblClick: function(e) {
+        this.handleClick('itemdblclick', e);
+    },
+
+    
+    handleClick: function(name, e) {
+        var me = this,
+            position = me.getEventXY(e),
+            seriesItems = me.series.items,
+            i, ln, series,
+            item;
+
+        
+        
+        for (i = 0, ln = seriesItems.length; i < ln; i++) {
+            series = seriesItems[i];
+            if (Ext.draw.Draw.withinBox(position[0], position[1], series.bbox)) {
+                if (series.getItemForPoint) {
+                    item = series.getItemForPoint(position[0], position[1]);
+                    if (item) {
+                        series.fireEvent(name, item);
+                    }
+                }
+            }
+        }
+    },
+
+    
+    onMouseDown: function(e) {
+        var me = this,
+            position = me.getEventXY(e),
+            seriesItems = me.series.items,
+            i, ln, series,
+            item;
+
+        if (me.enableMask) {
+            me.mixins.mask.onMouseDown.call(me, e);
+        }
+        
+        
+        for (i = 0, ln = seriesItems.length; i < ln; i++) {
+            series = seriesItems[i];
+            if (Ext.draw.Draw.withinBox(position[0], position[1], series.bbox)) {
+                if (series.getItemForPoint) {
+                    item = series.getItemForPoint(position[0], position[1]);
+                    if (item) {
+                        series.fireEvent('itemmousedown', item);
+                    }
+                }
+            }
+        }
+    },
+
+    
+    onMouseUp: function(e) {
+        var me = this,
+            position = me.getEventXY(e),
+            seriesItems = me.series.items,
+            i, ln, series,
+            item;
+
+        if (me.enableMask) {
+            me.mixins.mask.onMouseUp.call(me, e);
+        }
+        
+        
+        for (i = 0, ln = seriesItems.length; i < ln; i++) {
+            series = seriesItems[i];
+            if (Ext.draw.Draw.withinBox(position[0], position[1], series.bbox)) {
+                if (series.getItemForPoint) {
+                    item = series.getItemForPoint(position[0], position[1]);
+                    if (item) {
+                        series.fireEvent('itemmouseup', item);
+                    }
+                }
+            }
+        }
+    },
+
+    
+    onMouseMove: function(e) {
+        var me = this,
+            position = me.getEventXY(e),
+            seriesItems = me.series.items,
+            i, ln, series,
+            item, last, storeItem, storeField;
+
+        
+        if (me.enableMask) {
+            me.mixins.mask.onMouseMove.call(me, e);
+        }
+        
+        
+        for (i = 0, ln = seriesItems.length; i < ln; i++) {
+            series = seriesItems[i];
+            if (Ext.draw.Draw.withinBox(position[0], position[1], series.bbox)) {
+                if (series.getItemForPoint) {
+                    item = series.getItemForPoint(position[0], position[1]);
+                    last = series._lastItemForPoint;
+                    storeItem = series._lastStoreItem;
+                    storeField = series._lastStoreField;
+
+
+                    if (item !== last || item && (item.storeItem != storeItem || item.storeField != storeField)) {
+                        if (last) {
+                            series.fireEvent('itemmouseout', last);
+                            delete series._lastItemForPoint;
+                            delete series._lastStoreField;
+                            delete series._lastStoreItem;
+                        }
+                        if (item) {
+                            series.fireEvent('itemmouseover', item);
+                            series._lastItemForPoint = item;
+                            series._lastStoreItem = item.storeItem;
+                            series._lastStoreField = item.storeField;
+                        }
+                    }
+                }
+            } else {
+                last = series._lastItemForPoint;
+                if (last) {
+                    series.fireEvent('itemmouseout', last);
+                    delete series._lastItemForPoint;
+                    delete series._lastStoreField;
+                    delete series._lastStoreItem;
+                }
+            }
+        }
+    },
+
+    
+    onMouseLeave: function(e) {
+        var me = this,
+            seriesItems = me.series.items,
+            i, ln, series;
+
+        if (me.enableMask) {
+            me.mixins.mask.onMouseLeave.call(me, e);
+        }
+        for (i = 0, ln = seriesItems.length; i < ln; i++) {
+            series = seriesItems[i];
+            delete series._lastItemForPoint;
+        }
+    },
+
+    
+    delayRefresh: function() {
+        var me = this;
+        if (!me.refreshTask) {
+            me.refreshTask = new Ext.util.DelayedTask(me.refresh, me);
+        }
+        me.refreshTask.delay(me.refreshBuffer);
+    },
+
+    
+    refresh: function() {
+        var me = this;
+            
+        if (me.rendered && me.curWidth !== undefined && me.curHeight !== undefined) {
+            if (!me.isVisible(true) && !me.refreshPending) {
+                me.setShowListeners('mon');
+                me.refreshPending = true;
+                return;
+            }
+            if (me.fireEvent('beforerefresh', me) !== false) {
+                me.redraw();
+                me.fireEvent('refresh', me);
+            }
+        }
+    },
+    
+    onShow: function(){
+        var me = this;
+        me.callParent(arguments);
+        if (me.refreshPending) {
+            me.delayRefresh();
+            me.setShowListeners('mun');
+        }
+        delete me.refreshPending;
+    },
+    
+    setShowListeners: function(method){
+        var me = this;
+        me[method](Ext.container.Container.hierarchyEventSource, {
+            scope: me,
+            single: true,
+            show: me.forceRefresh,
+            expand: me.forceRefresh
+        });
+    },
+    
+    forceRefresh: function(container) {
+        var me = this;
+        if (me.isDescendantOf(container) && me.refreshPending) {
+            
+            
+            me.setShowListeners('mun');
+            me.delayRefresh();
+        }    
+        delete me.refreshPending;
+    },
+
+    bindStore: function(store, initial) {
+        var me = this;
+        me.mixins.bindable.bindStore.apply(me, arguments);
+        if (me.store && !initial) {
+            me.refresh();
+        }
+    },
+    
+    getStoreListeners: function() {
+        var refresh = this.refresh,
+            delayRefresh = this.delayRefresh;
+            
+        return {
+            refresh: refresh,
+            add: delayRefresh,
+            remove: delayRefresh,
+            update: delayRefresh,
+            clear: refresh
+        };
+    },
+
+    
+    initializeAxis: function(axis) {
+        var me = this,
+            chartBBox = me.chartBBox,
+            w = chartBBox.width,
+            h = chartBBox.height,
+            x = chartBBox.x,
+            y = chartBBox.y,
+            themeAttrs = me.themeAttrs,
+            config = {
+                chart: me
+            };
+        if (themeAttrs) {
+            config.axisStyle = Ext.apply({}, themeAttrs.axis);
+            config.axisLabelLeftStyle = Ext.apply({}, themeAttrs.axisLabelLeft);
+            config.axisLabelRightStyle = Ext.apply({}, themeAttrs.axisLabelRight);
+            config.axisLabelTopStyle = Ext.apply({}, themeAttrs.axisLabelTop);
+            config.axisLabelBottomStyle = Ext.apply({}, themeAttrs.axisLabelBottom);
+            config.axisTitleLeftStyle = Ext.apply({}, themeAttrs.axisTitleLeft);
+            config.axisTitleRightStyle = Ext.apply({}, themeAttrs.axisTitleRight);
+            config.axisTitleTopStyle = Ext.apply({}, themeAttrs.axisTitleTop);
+            config.axisTitleBottomStyle = Ext.apply({}, themeAttrs.axisTitleBottom);
+        }
+        switch (axis.position) {
+            case 'top':
+                Ext.apply(config, {
+                    length: w,
+                    width: h,
+                    x: x,
+                    y: y
+                });
+            break;
+            case 'bottom':
+                Ext.apply(config, {
+                    length: w,
+                    width: h,
+                    x: x,
+                    y: h
+                });
+            break;
+            case 'left':
+                Ext.apply(config, {
+                    length: h,
+                    width: w,
+                    x: x,
+                    y: h
+                });
+            break;
+            case 'right':
+                Ext.apply(config, {
+                    length: h,
+                    width: w,
+                    x: w,
+                    y: h
+                });
+            break;
+        }
+        if (!axis.chart) {
+            Ext.apply(config, axis);
+            axis = me.axes.replace(Ext.createByAlias('axis.' + axis.type.toLowerCase(), config));
+        }
+        else {
+            Ext.apply(axis, config);
+        }
+    },
+
+
+    
+    alignAxes: function() {
+        var me = this,
+            axes = me.axes,
+            axesItems = axes.items,
+            axis,
+            legend = me.legend,
+            edges = ['top', 'right', 'bottom', 'left'],
+            edge,
+            i, ln,
+            chartBBox,
+            insetPadding = me.insetPadding,
+            insets = {
+                top: insetPadding,
+                right: insetPadding,
+                bottom: insetPadding,
+                left: insetPadding
+            },
+            isVertical, bbox, pos;
+
+        function getAxis(edge) {
+            var i = axes.findIndex('position', edge);
+            return (i < 0) ? null : axes.getAt(i);
+        }
+
+        
+        for (i = 0, ln = edges.length; i < ln; i++) {
+            edge = edges[i];
+            isVertical = (edge === 'left' || edge === 'right');
+            axis = getAxis(edge);
+
+            
+            if (legend !== false) {
+                if (legend.position === edge) {
+                    bbox = legend.getBBox();
+                    insets[edge] += (isVertical ? bbox.width : bbox.height) + insets[edge];
+                }
+            }
+
+            
+            
+            if (axis && axis.bbox) {
+                bbox = axis.bbox;
+                insets[edge] += (isVertical ? bbox.width : bbox.height);
+            }
+        }
+        
+        chartBBox = {
+            x: insets.left,
+            y: insets.top,
+            width: me.curWidth - insets.left - insets.right,
+            height: me.curHeight - insets.top - insets.bottom
+        };
+        me.chartBBox = chartBBox;
+
+        
+        
+        for (i = 0, ln = axesItems.length; i < ln; i++) {
+            axis = axesItems[i];
+            pos = axis.position;
+            isVertical = (pos === 'left' || pos === 'right');
+
+            axis.x = (pos === 'right' ? chartBBox.x + chartBBox.width : chartBBox.x);
+            axis.y = (pos === 'top' ? chartBBox.y : chartBBox.y + chartBBox.height);
+            axis.width = (isVertical ? chartBBox.width : chartBBox.height);
+            axis.length = (isVertical ? chartBBox.height : chartBBox.width);
+        }
+    },
+
+    
+    initializeSeries: function(series, idx) {
+        var me = this,
+            themeAttrs = me.themeAttrs,
+            seriesObj, markerObj, seriesThemes, st,
+            markerThemes, colorArrayStyle = [],
+            i = 0, l,
+            config = {
+                chart: me,
+                seriesId: series.seriesId
+            };
+        if (themeAttrs) {
+            seriesThemes = themeAttrs.seriesThemes;
+            markerThemes = themeAttrs.markerThemes;
+            seriesObj = Ext.apply({}, themeAttrs.series);
+            markerObj = Ext.apply({}, themeAttrs.marker);
+            config.seriesStyle = Ext.apply(seriesObj, seriesThemes[idx % seriesThemes.length]);
+            config.seriesLabelStyle = Ext.apply({}, themeAttrs.seriesLabel);
+            config.markerStyle = Ext.apply(markerObj, markerThemes[idx % markerThemes.length]);
+            if (themeAttrs.colors) {
+                config.colorArrayStyle = themeAttrs.colors;
+            } else {
+                colorArrayStyle = [];
+                for (l = seriesThemes.length; i < l; i++) {
+                    st = seriesThemes[i];
+                    if (st.fill || st.stroke) {
+                        colorArrayStyle.push(st.fill || st.stroke);
+                    }
+                }
+                if (colorArrayStyle.length) {
+                    config.colorArrayStyle = colorArrayStyle;
+                }
+            }
+            config.seriesIdx = idx;
+        }
+        if (series instanceof Ext.chart.series.Series) {
+            Ext.apply(series, config);
+        } else {
+            Ext.applyIf(config, series);
+            series = me.series.replace(Ext.createByAlias('series.' + series.type.toLowerCase(), config));
+        }
+        if (series.initialize) {
+            series.initialize();
+        }
+    },
+
+    
+    getMaxGutter: function() {
+        var me = this,
+            seriesItems = me.series.items,
+            i, ln, series,
+            maxGutter = [0, 0],
+            gutter;
+        for (i = 0, ln = seriesItems.length; i < ln; i++) {
+            series = seriesItems[i];
+            gutter = series.getGutters && series.getGutters() || [0, 0];
+            maxGutter[0] = Math.max(maxGutter[0], gutter[0]);
+            maxGutter[1] = Math.max(maxGutter[1], gutter[1]);
+        }
+        me.maxGutter = maxGutter;
+    },
+
+    
+    drawAxis: function(axis) {
+        axis.drawAxis();
+    },
+
+    
+    drawCharts: function(series) {
+        series.triggerafterrender = false;
+        series.drawSeries();
+        if (!this.animate) {
+            series.fireEvent('afterrender');
+        }
+    },
+    
+    save: function(config){
+        return Ext.draw.Surface.save(this.surface, config);
+    },
+    
+    destroy: function() {
+        Ext.destroy(this.surface);
+        this.bindStore(null);
+        this.callParent(arguments);
+    }
+});
+
+
+Ext.define('Ext.chart.Highlight', {
+
+    
+
+    requires: ['Ext.fx.Anim'],
+
+    
+
+    
+    highlight: false,
+
+    highlightCfg : {
+        fill: '#fdd',
+        "stroke-width": 5,
+        stroke: '#f55'
+    },
+
+    constructor: function(config) {
+        if (config.highlight) {
+            if (config.highlight !== true) { 
+                this.highlightCfg = Ext.merge(this.highlightCfg, config.highlight);
+            }
+        }
+    },
+
+    
+    highlightItem: function(item) {
+        if (!item) {
+            return;
+        }
+        
+        var me = this,
+            sprite = item.sprite,
+            opts = Ext.merge({}, me.highlightCfg, me.highlight),
+            surface = me.chart.surface,
+            animate = me.chart.animate,
+            p, from, to, pi;
+
+        if (!me.highlight || !sprite || sprite._highlighted) {
+            return;
+        }
+        if (sprite._anim) {
+            sprite._anim.paused = true;
+        }
+        sprite._highlighted = true;
+        if (!sprite._defaults) {
+            sprite._defaults = Ext.apply({}, sprite.attr);
+            from = {};
+            to = {};
+            for (p in opts) {
+                if (! (p in sprite._defaults)) {
+                    sprite._defaults[p] = surface.availableAttrs[p];
+                }
+                from[p] = sprite._defaults[p];
+                to[p] = opts[p];
+                if (Ext.isObject(opts[p])) {
+                    from[p] = {};
+                    to[p] = {};
+                    Ext.apply(sprite._defaults[p], sprite.attr[p]);
+                    Ext.apply(from[p], sprite._defaults[p]);
+                    for (pi in sprite._defaults[p]) {
+                        if (! (pi in opts[p])) {
+                            to[p][pi] = from[p][pi];
+                        } else {
+                            to[p][pi] = opts[p][pi];
+                        }
+                    }
+                    for (pi in opts[p]) {
+                        if (! (pi in to[p])) {
+                            to[p][pi] = opts[p][pi];
+                        }
+                    }
+                }
+            }
+            sprite._from = from;
+            sprite._to = to;
+            sprite._endStyle = to;
+        }
+        if (animate) {
+            sprite._anim = new Ext.fx.Anim({
+                target: sprite,
+                from: sprite._from,
+                to: sprite._to,
+                duration: 150
+            });
+        } else {
+            sprite.setAttributes(sprite._to, true);
+        }
+    },
+
+    
+    unHighlightItem: function() {
+        if (!this.highlight || !this.items) {
+            return;
+        }
+
+        var me = this,
+            items = me.items,
+            len = items.length,
+            opts = Ext.merge({}, me.highlightCfg, me.highlight),
+            animate = me.chart.animate,
+            i = 0,
+            obj, p, sprite;
+        for (; i < len; i++) {
+            if (!items[i]) {
+                continue;
+            }
+            sprite = items[i].sprite;
+            if (sprite && sprite._highlighted) {
+                if (sprite._anim) {
+                    sprite._anim.paused = true;
+                }
+                obj = {};
+                for (p in opts) {
+                    if (Ext.isObject(sprite._defaults[p])) {
+                        obj[p] = {};
+                        Ext.apply(obj[p], sprite._defaults[p]);
+                    }
+                    else {
+                        obj[p] = sprite._defaults[p];
+                    }
+                }
+                if (animate) {
+                    
+                    sprite._endStyle = obj;
+                    sprite._anim = new Ext.fx.Anim({
+                        target: sprite,
+                        to: obj,
+                        duration: 150
+                    });
+                }
+                else {
+                    sprite.setAttributes(obj, true);
+                }
+                delete sprite._highlighted;
+                
+            }
+        }
+    },
+
+    cleanHighlights: function() {
+        if (!this.highlight) {
+            return;
+        }
+
+        var group = this.group,
+            markerGroup = this.markerGroup,
+            i = 0,
+            l;
+        for (l = group.getCount(); i < l; i++) {
+            delete group.getAt(i)._defaults;
+        }
+        if (markerGroup) {
+            for (l = markerGroup.getCount(); i < l; i++) {
+                delete markerGroup.getAt(i)._defaults;
+            }
+        }
+    }
+});
+
+
+Ext.define('Ext.chart.Label', {
+
+    
+
+    requires: ['Ext.draw.Color'],
+
+    
+
+    
+
+    
+    colorStringRe: /url\s*\(\s*#([^\/)]+)\s*\)/,
+
+    
+    constructor: function(config) {
+        var me = this;
+        me.label = Ext.applyIf(me.label || {},
+        {
+            display: "none",
+            color: "#000",
+            field: "name",
+            minMargin: 50,
+            font: "11px Helvetica, sans-serif",
+            orientation: "horizontal",
+            renderer: function(v) {
+                return v;
+            }
+        });
+
+        if (me.label.display !== 'none') {
+            me.labelsGroup = me.chart.surface.getGroup(me.seriesId + '-labels');
+        }
+    },
+
+    
+    renderLabels: function() {
+        var me = this,
+            chart = me.chart,
+            gradients = chart.gradients,
+            items = me.items,
+            animate = chart.animate,
+            config = me.label,
+            display = config.display,
+            color = config.color,
+            field = [].concat(config.field),
+            group = me.labelsGroup,
+            groupLength = (group || 0) && group.length,
+            store = me.chart.getChartStore(),
+            len = store.getCount(),
+            itemLength = (items || 0) && items.length,
+            ratio = itemLength / len,
+            gradientsCount = (gradients || 0) && gradients.length,
+            Color = Ext.draw.Color,
+            hides = [],
+            gradient, i, count, groupIndex, index, j, k, colorStopTotal, colorStopIndex, colorStop, item, label,
+            storeItem, sprite, spriteColor, spriteBrightness, labelColor, colorString;
+
+        if (display == 'none') {
+            return;
+        }
+        
+        if(itemLength == 0){
+            while(groupLength--) {
+                hides.push(groupLength);
+            }
+        } else {
+            for (i = 0, count = 0, groupIndex = 0; i < len; i++) {
+                index = 0;
+                for (j = 0; j < ratio; j++) {
+                    item = items[count];
+                    label = group.getAt(groupIndex);
+                    storeItem = store.getAt(i);
+                    
+                    while(this.__excludes && this.__excludes[index]) {
+                        index++;
+                    }
+
+                    if (!item && label) {
+                        label.hide(true);
+                        groupIndex++;
+                    }
+
+                    if (item && field[j]) {
+                        if (!label) {
+                            label = me.onCreateLabel(storeItem, item, i, display, j, index);
+                        }
+                        me.onPlaceLabel(label, storeItem, item, i, display, animate, j, index);
+                        groupIndex++;
+
+                        
+                        if (config.contrast && item.sprite) {
+                            sprite = item.sprite;
+                            
+                            if (sprite._endStyle) {
+                                colorString = sprite._endStyle.fill;
+                            }
+                            else if (sprite._to) {
+                                colorString = sprite._to.fill;
+                            }
+                            else {
+                                colorString = sprite.attr.fill;
+                            }
+                            colorString = colorString || sprite.attr.fill;
+
+                            spriteColor = Color.fromString(colorString);
+                            
+                            if (colorString && !spriteColor) {
+                                colorString = colorString.match(me.colorStringRe)[1];
+                                for (k = 0; k < gradientsCount; k++) {
+                                    gradient = gradients[k];
+                                    if (gradient.id == colorString) {
+                                        
+                                        colorStop = 0; colorStopTotal = 0;
+                                        for (colorStopIndex in gradient.stops) {
+                                            colorStop++;
+                                            colorStopTotal += Color.fromString(gradient.stops[colorStopIndex].color).getGrayscale();
+                                        }
+                                        spriteBrightness = (colorStopTotal / colorStop) / 255;
+                                        break;
+                                    }
+                                }
+                            }
+                            else {
+                                spriteBrightness = spriteColor.getGrayscale() / 255;
+                            }
+                            if (label.isOutside) {
+                                spriteBrightness = 1;
+                            }
+                            labelColor = Color.fromString(label.attr.color || label.attr.fill).getHSL();
+                            labelColor[2] = spriteBrightness > 0.5 ? 0.2 : 0.8;
+                            label.setAttributes({
+                                fill: String(Color.fromHSL.apply({}, labelColor))
+                            }, true);
+                        }
+
+                    }
+                    count++;
+                    index++;
+                }
+            }
+            groupLength = group.length;
+        
+            while(groupLength > groupIndex){
+                hides.push(groupIndex);
+                groupIndex++;
+           }
+        }
+        me.hideLabels(hides);
+    },
+
+    hideLabels: function(hides){
+        var labelsGroup = this.labelsGroup,
+            hlen = !!hides && hides.length;
+
+        if (!labelsGroup) {
+            return;
+        }
+
+        if (hlen === false) {
+            hlen = labelsGroup.getCount();
+            while (hlen--) {
+              labelsGroup.getAt(hlen).hide(true);
+            }
+        } else {
+            while(hlen--) {
+                labelsGroup.getAt(hides[hlen]).hide(true);
+            }
+        }
+    }
+});
+
+
+Ext.define('Ext.chart.TipSurface', {
+
+    
+
+    extend: 'Ext.draw.Component',
+
+    
+
+    spriteArray: false,
+    renderFirst: true,
+
+    constructor: function(config) {
+        this.callParent([config]);
+        if (config.sprites) {
+            this.spriteArray = [].concat(config.sprites);
+            delete config.sprites;
+        }
+    },
+
+    onRender: function() {
+        var me = this,
+            i = 0,
+            l = 0,
+            sp,
+            sprites;
+            this.callParent(arguments);
+        sprites = me.spriteArray;
+        if (me.renderFirst && sprites) {
+            me.renderFirst = false;
+            for (l = sprites.length; i < l; i++) {
+                sp = me.surface.add(sprites[i]);
+                sp.setAttributes({
+                    hidden: false
+                },
+                true);
+            }
+        }
+    }
+});
+
+
+Ext.define('Ext.chart.Tip', {
+
+    
+
+    requires: ['Ext.tip.ToolTip', 'Ext.chart.TipSurface'],
+
+    
+
+    constructor: function(config) {
+        var me = this,
+            surface,
+            sprites,
+            tipSurface;
+        if (config.tips) {
+            me.tipTimeout = null;
+            me.tipConfig = Ext.apply({}, config.tips, {
+                renderer: Ext.emptyFn,
+                constrainPosition: true,
+                autoHide: true
+            });
+            me.tooltip = new Ext.tip.ToolTip(me.tipConfig);
+            me.chart.surface.on('mousemove', me.tooltip.onMouseMove, me.tooltip);
+            me.chart.surface.on('mouseleave', function() {
+                me.hideTip();
+            });
+            if (me.tipConfig.surface) {
+                
+                surface = me.tipConfig.surface;
+                sprites = surface.sprites;
+                tipSurface = new Ext.chart.TipSurface({
+                    id: 'tipSurfaceComponent',
+                    sprites: sprites
+                });
+                if (surface.width && surface.height) {
+                    tipSurface.setSize(surface.width, surface.height);
+                }
+                me.tooltip.add(tipSurface);
+                me.spriteTip = tipSurface;
+            }
+        }
+    },
+
+    showTip: function(item) {
+        var me = this,
+            tooltip,
+            spriteTip,
+            tipConfig,
+            trackMouse,
+            sprite,
+            surface,
+            surfaceExt,
+            pos,
+            x,
+            y;
+        if (!me.tooltip) {
+            return;
+        }
+        clearTimeout(me.tipTimeout);
+        tooltip = me.tooltip;
+        spriteTip = me.spriteTip;
+        tipConfig = me.tipConfig;
+        trackMouse = tooltip.trackMouse;
+        if (!trackMouse) {
+            tooltip.trackMouse = true;
+            sprite = item.sprite;
+            surface = sprite.surface;
+            surfaceExt = Ext.get(surface.getId());
+            if (surfaceExt) {
+                pos = surfaceExt.getXY();
+                x = pos[0] + (sprite.attr.x || 0) + (sprite.attr.translation && sprite.attr.translation.x || 0);
+                y = pos[1] + (sprite.attr.y || 0) + (sprite.attr.translation && sprite.attr.translation.y || 0);
+                tooltip.targetXY = [x, y];
+            }
+        }
+        if (spriteTip) {
+            tipConfig.renderer.call(tooltip, item.storeItem, item, spriteTip.surface);
+        } else {
+            tipConfig.renderer.call(tooltip, item.storeItem, item);
+        }
+        tooltip.show();
+        tooltip.trackMouse = trackMouse;
+    },
+
+    hideTip: function(item) {
+        var tooltip = this.tooltip;
+        if (!tooltip) {
+            return;
+        }
+        clearTimeout(this.tipTimeout);
+        this.tipTimeout = setTimeout(function() {
+            tooltip.hide();
+        }, 0);
+    }
+});
+
+
+Ext.define('Ext.chart.axis.Abstract', {
+
+    
+
+    requires: ['Ext.chart.Chart'],
+
+    
+    
+    
+
+    
+
+    
+    constructor: function(config) {
+        config = config || {};
+
+        var me = this,
+            pos = config.position || 'left';
+
+        pos = pos.charAt(0).toUpperCase() + pos.substring(1);
+        
+        config.label = Ext.apply(config['axisLabel' + pos + 'Style'] || {}, config.label || {});
+        config.axisTitleStyle = Ext.apply(config['axisTitle' + pos + 'Style'] || {}, config.labelTitle || {});
+        Ext.apply(me, config);
+        me.fields = Ext.Array.from(me.fields);
+        this.callParent();
+        me.labels = [];
+        me.getId();
+        me.labelGroup = me.chart.surface.getGroup(me.axisId + "-labels");
+    },
+
+    alignment: null,
+    grid: false,
+    steps: 10,
+    x: 0,
+    y: 0,
+    minValue: 0,
+    maxValue: 0,
+
+    getId: function() {
+        return this.axisId || (this.axisId = Ext.id(null, 'ext-axis-'));
+    },
+
+    
+    processView: Ext.emptyFn,
+
+    drawAxis: Ext.emptyFn,
+    addDisplayAndLabels: Ext.emptyFn
+});
+
+
+Ext.define('Ext.chart.axis.Axis', {
+
+    
+
+    extend: 'Ext.chart.axis.Abstract',
+
+    alternateClassName: 'Ext.chart.Axis',
+
+    requires: ['Ext.draw.Draw'],
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+    forceMinMax: false,
+
+    
+    dashSize: 3,
+
+    
+    position: 'bottom',
+
+    
+    skipFirst: false,
+
+    
+    length: 0,
+
+    
+    width: 0,
+
+    
+    adjustEnd: true,
+
+    majorTickSteps: false,
+
+    
+    applyData: Ext.emptyFn,
+
+    getRange: function () {
+        var me = this,
+            chart = me.chart,
+            store = chart.getChartStore(),
+            data = store.data.items,
+            series = chart.series.items,
+            position = me.position,
+            boundedAxes,
+            seriesClasses = Ext.chart.series,
+            aggregations = [],
+            min = Infinity, max = -Infinity,
+            vertical = me.position === 'left' || me.position === 'right',
+            i, ln, ln2, j, k, dataLength = data.length, aggregates,
+            countedFields = {},
+            allFields = {},
+            excludable = true,
+            fields, fieldMap, record, field, value;
+
+        fields = me.fields;
+        for (j = 0, ln = fields.length; j < ln; j++) {
+            allFields[fields[j]] = true;
+        }
+
+        for (i = 0, ln = series.length; i < ln; i++) {
+            if (series[i].seriesIsHidden) {
+                continue;
+            }
+            if (!series[i].getAxesForXAndYFields) {
+                continue;
+            }
+
+            boundedAxes = series[i].getAxesForXAndYFields();
+            if (boundedAxes.xAxis && boundedAxes.xAxis !== position && boundedAxes.yAxis && boundedAxes.yAxis !== position) {
+                
+                continue;
+            }
+
+            if (seriesClasses.Bar && series[i] instanceof seriesClasses.Bar && !series[i].column) {
+                
+                fields = vertical ? Ext.Array.from(series[i].xField) : Ext.Array.from(series[i].yField);
+            } else {
+                fields = vertical ? Ext.Array.from(series[i].yField) : Ext.Array.from(series[i].xField);
+            }
+
+            if (me.fields.length) {
+                for (j = 0, ln2 = fields.length; j < ln2; j++) {
+                    if (allFields[fields[j]]) {
+                        break;
+                    }
+                }
+                if (j == ln2) {
+                    
+                    continue;
+                }
+            }
+
+            if (aggregates = series[i].stacked) {
+                
+                if (seriesClasses.Bar && series[i] instanceof seriesClasses.Bar) {
+                    if (series[i].column != vertical) {
+                        aggregates = false;
+                        excludable = false;
+                    }
+                }
+                
+                else if (!vertical) {
+                    aggregates = false;
+                    excludable = false;
+                }
+            }
+
+
+            if (aggregates) {
+                fieldMap = {};
+                for (j = 0; j < fields.length; j++) {
+                    if (excludable && series[i].__excludes && series[i].__excludes[j]) {
+                        continue;
+                    }
+                    if (!allFields[fields[j]]) {
+                        Ext.Logger.warn('Field `' + fields[j] + '` is not included in the ' + position + ' axis config.');
+                    }
+                    allFields[fields[j]] = fieldMap[fields[j]] = true;
+                }
+                aggregations.push({
+                    fields: fieldMap,
+                    value: 0
+                });
+            } else {
+
+                if (!fields || fields.length == 0) {
+                    fields = me.fields;
+                }
+                for (j = 0; j < fields.length; j++) {
+                    if (excludable && series[i].__excludes && series[i].__excludes[j]) {
+                        continue;
+                    }
+                    allFields[fields[j]] = countedFields[fields[j]] = true;
+                }
+            }
+        }
+
+        for (i = 0; i < dataLength; i++) {
+            record = data[i];
+            for (k = 0; k < aggregations.length; k++) {
+                aggregations[k].value = 0;
+            }
+            for (field in allFields) {
+                value = record.get(field);
+                if (isNaN(value)) {
+                    continue;
+                }
+                if (value === undefined) {
+                    value = 0;
+                }
+                if (countedFields[field]) {
+                    if (min > value) {
+                        min = value;
+                    }
+                    if (max < value) {
+                        max = value;
+                    }
+                }
+                for (k = 0; k < aggregations.length; k++) {
+                    if (aggregations[k].fields[field]) {
+                        aggregations[k].value += value;
+                        
+                        if (min > 0) {
+                            min = 0;
+                        }
+                        if (max < aggregations[k].value) {
+                            max = aggregations[k].value;
+                        }
+                    }
+                }
+            }
+        }
+
+        if (!isFinite(max)) {
+            max = me.prevMax || 0;
+        }
+        if (!isFinite(min)) {
+            min = me.prevMin || 0;
+        }
+
+        
+        if (min != max && (max != Math.floor(max))) {
+            max = Math.floor(max) + 1;
+        }
+
+        if (!isNaN(me.minimum)) {
+            min = me.minimum;
+        }
+
+        if (!isNaN(me.maximum)) {
+            max = me.maximum;
+        }
+
+        if (min >= max) {
+            
+            max = min + 1;
+        }
+
+        return {min: min, max: max};
+    },
+
+    
+    calcEnds: function () {
+        var me = this,
+            range = me.getRange(),
+            min = range.min,
+            max = range.max,
+            steps, prettyNumbers, out, changedRange;
+
+        steps = (Ext.isNumber(me.majorTickSteps) ? me.majorTickSteps + 1 : me.steps);
+        prettyNumbers = !(Ext.isNumber(me.maximum) && Ext.isNumber(me.minimum) && Ext.isNumber(me.majorTickSteps) && me.majorTickSteps > 0);
+
+        out = Ext.draw.Draw.snapEnds(min, max, steps, prettyNumbers);
+
+        if (Ext.isNumber(me.maximum)) {
+            out.to = me.maximum;
+            changedRange = true;
+        }
+        if (Ext.isNumber(me.minimum)) {
+            out.from = me.minimum;
+            changedRange = true;
+        }
+        if (me.adjustMaximumByMajorUnit) {
+            out.to = Math.ceil(out.to / out.step) * out.step;
+            changedRange = true;
+        }
+        if (me.adjustMinimumByMajorUnit) {
+            out.from = Math.floor(out.from / out.step) * out.step;
+            changedRange = true;
+        }
+
+        if (changedRange) {
+            out.steps = Math.ceil((out.to - out.from) / out.step);            
+        }
+
+        me.prevMin = (min == max ? 0 : min);
+        me.prevMax = max;
+        return out;
+    },
+
+    
+    drawAxis: function (init) {
+        var me = this,
+            i, 
+            x = me.x,
+            y = me.y,
+            gutterX = me.chart.maxGutter[0],
+            gutterY = me.chart.maxGutter[1],
+            dashSize = me.dashSize,
+            subDashesX = me.minorTickSteps || 0,
+            subDashesY = me.minorTickSteps || 0,
+            length = me.length,
+            position = me.position,
+            inflections = [],
+            calcLabels = false,
+            stepCalcs = me.applyData(),
+            step = stepCalcs.step,
+            steps = stepCalcs.steps,
+            from = stepCalcs.from,
+            to = stepCalcs.to,
+            trueLength,
+            currentX,
+            currentY,
+            path,
+            dashesX,
+            dashesY,
+            delta;
+
+        
+        
+        
+        if (me.hidden || isNaN(step) || (from > to)) {
+            return;
+        }
+
+        me.from = stepCalcs.from;
+        me.to = stepCalcs.to;
+
+        if (position == 'left' || position == 'right') {
+            currentX = Math.floor(x) + 0.5;
+            path = ["M", currentX, y, "l", 0, -length];
+            trueLength = length - (gutterY * 2);
+        }
+        else {
+            currentY = Math.floor(y) + 0.5;
+            path = ["M", x, currentY, "l", length, 0];
+            trueLength = length - (gutterX * 2);
+        }
+
+        
+        delta = steps && trueLength / steps;
+        dashesX = Math.max(subDashesX + 1, 0);
+        dashesY = Math.max(subDashesY + 1, 0);
+        if (me.type == 'Numeric' || me.type == 'Time') {
+            calcLabels = true;
+            me.labels = [stepCalcs.from];
+        }
+
+        if (position == 'right' || position == 'left') {
+            currentY = y - gutterY;
+            currentX = x - ((position == 'left') * dashSize * 2);
+            while (currentY >= y - gutterY - trueLength) {
+                path.push("M", currentX, Math.floor(currentY) + 0.5, "l", dashSize * 2 + 1, 0);
+                if (currentY != y - gutterY) {
+                    for (i = 1; i < dashesY; i++) {
+                        path.push("M", currentX + dashSize, Math.floor(currentY + delta * i / dashesY) + 0.5, "l", dashSize + 1, 0);
+                    }
+                }
+                inflections.push([ Math.floor(x), Math.floor(currentY) ]);
+                currentY -= delta;
+
+                if (calcLabels) {
+                    me.labels.push(me.labels[me.labels.length - 1] + step);
+                }
+
+                if (delta === 0) {
+                    break;
+                }
+            }
+            if (Math.round(currentY + delta - (y - gutterY - trueLength))) {
+                path.push("M", currentX, Math.floor(y - length + gutterY) + 0.5, "l", dashSize * 2 + 1, 0);
+                for (i = 1; i < dashesY; i++) {
+                    path.push("M", currentX + dashSize, Math.floor(y - length + gutterY + delta * i / dashesY) + 0.5, "l", dashSize + 1, 0);
+                }
+                inflections.push([ Math.floor(x), Math.floor(currentY) ]);
+                if (calcLabels) {
+                    me.labels.push(me.labels[me.labels.length - 1] + step);
+                }
+            }
+        } else {
+            currentX = x + gutterX;
+            currentY = y - ((position == 'top') * dashSize * 2);
+            while (currentX <= x + gutterX + trueLength) {
+                path.push("M", Math.floor(currentX) + 0.5, currentY, "l", 0, dashSize * 2 + 1);
+                if (currentX != x + gutterX) {
+                    for (i = 1; i < dashesX; i++) {
+                        path.push("M", Math.floor(currentX - delta * i / dashesX) + 0.5, currentY, "l", 0, dashSize + 1);
+                    }
+                }
+                inflections.push([ Math.floor(currentX), Math.floor(y) ]);
+                currentX += delta;
+                if (calcLabels) {
+                    me.labels.push(me.labels[me.labels.length - 1] + step);
+                }
+                if (delta === 0) {
+                    break;
+                }
+            }
+            if (Math.round(currentX - delta - (x + gutterX + trueLength))) {
+                path.push("M", Math.floor(x + length - gutterX) + 0.5, currentY, "l", 0, dashSize * 2 + 1);
+                for (i = 1; i < dashesX; i++) {
+                    path.push("M", Math.floor(x + length - gutterX - delta * i / dashesX) + 0.5, currentY, "l", 0, dashSize + 1);
+                }
+                inflections.push([ Math.floor(currentX), Math.floor(y) ]);
+                if (calcLabels) {
+                    me.labels.push(me.labels[me.labels.length - 1] + step);
+                }
+            }
+        }
+
+        
+        if (calcLabels) {
+            me.labels[inflections.length - 1] = +(me.labels[inflections.length - 1]).toFixed(10);
+        }
+
+        if (!me.axis) {
+            me.axis = me.chart.surface.add(Ext.apply({
+                type: 'path',
+                path: path
+            }, me.axisStyle));
+        }
+        me.axis.setAttributes({
+            path: path
+        }, true);
+        me.inflections = inflections;
+        if (!init && me.grid) {
+            me.drawGrid();
+        }
+        me.axisBBox = me.axis.getBBox();
+        me.drawLabel();
+    },
+
+    
+    drawGrid: function () {
+        var me = this,
+            surface = me.chart.surface,
+            grid = me.grid,
+            odd = grid.odd,
+            even = grid.even,
+            inflections = me.inflections,
+            ln = inflections.length - ((odd || even) ? 0 : 1),
+            position = me.position,
+            gutter = me.chart.maxGutter,
+            width = me.width - 2,
+            point, prevPoint,
+            i = 1,
+            path = [], styles, lineWidth, dlineWidth,
+            oddPath = [], evenPath = [];
+
+        if ((gutter[1] !== 0 && (position == 'left' || position == 'right')) ||
+            (gutter[0] !== 0 && (position == 'top' || position == 'bottom'))) {
+            i = 0;
+            ln++;
+        }
+        for (; i < ln; i++) {
+            point = inflections[i];
+            prevPoint = inflections[i - 1];
+            if (odd || even) {
+                path = (i % 2) ? oddPath : evenPath;
+                styles = ((i % 2) ? odd : even) || {};
+                lineWidth = (styles.lineWidth || styles['stroke-width'] || 0) / 2;
+                dlineWidth = 2 * lineWidth;
+                if (position == 'left') {
+                    path.push("M", prevPoint[0] + 1 + lineWidth, prevPoint[1] + 0.5 - lineWidth,
+                        "L", prevPoint[0] + 1 + width - lineWidth, prevPoint[1] + 0.5 - lineWidth,
+                        "L", point[0] + 1 + width - lineWidth, point[1] + 0.5 + lineWidth,
+                        "L", point[0] + 1 + lineWidth, point[1] + 0.5 + lineWidth, "Z");
+                }
+                else if (position == 'right') {
+                    path.push("M", prevPoint[0] - lineWidth, prevPoint[1] + 0.5 - lineWidth,
+                        "L", prevPoint[0] - width + lineWidth, prevPoint[1] + 0.5 - lineWidth,
+                        "L", point[0] - width + lineWidth, point[1] + 0.5 + lineWidth,
+                        "L", point[0] - lineWidth, point[1] + 0.5 + lineWidth, "Z");
+                }
+                else if (position == 'top') {
+                    path.push("M", prevPoint[0] + 0.5 + lineWidth, prevPoint[1] + 1 + lineWidth,
+                        "L", prevPoint[0] + 0.5 + lineWidth, prevPoint[1] + 1 + width - lineWidth,
+                        "L", point[0] + 0.5 - lineWidth, point[1] + 1 + width - lineWidth,
+                        "L", point[0] + 0.5 - lineWidth, point[1] + 1 + lineWidth, "Z");
+                }
+                else {
+                    path.push("M", prevPoint[0] + 0.5 + lineWidth, prevPoint[1] - lineWidth,
+                        "L", prevPoint[0] + 0.5 + lineWidth, prevPoint[1] - width + lineWidth,
+                        "L", point[0] + 0.5 - lineWidth, point[1] - width + lineWidth,
+                        "L", point[0] + 0.5 - lineWidth, point[1] - lineWidth, "Z");
+                }
+            } else {
+                if (position == 'left') {
+                    path = path.concat(["M", point[0] + 0.5, point[1] + 0.5, "l", width, 0]);
+                }
+                else if (position == 'right') {
+                    path = path.concat(["M", point[0] - 0.5, point[1] + 0.5, "l", -width, 0]);
+                }
+                else if (position == 'top') {
+                    path = path.concat(["M", point[0] + 0.5, point[1] + 0.5, "l", 0, width]);
+                }
+                else {
+                    path = path.concat(["M", point[0] + 0.5, point[1] - 0.5, "l", 0, -width]);
+                }
+            }
+        }
+        if (odd || even) {
+            if (oddPath.length) {
+                if (!me.gridOdd && oddPath.length) {
+                    me.gridOdd = surface.add({
+                        type: 'path',
+                        path: oddPath
+                    });
+                }
+                me.gridOdd.setAttributes(Ext.apply({
+                    path: oddPath,
+                    hidden: false
+                }, odd || {}), true);
+            }
+            if (evenPath.length) {
+                if (!me.gridEven) {
+                    me.gridEven = surface.add({
+                        type: 'path',
+                        path: evenPath
+                    });
+                }
+                me.gridEven.setAttributes(Ext.apply({
+                    path: evenPath,
+                    hidden: false
+                }, even || {}), true);
+            }
+        }
+        else {
+            if (path.length) {
+                if (!me.gridLines) {
+                    me.gridLines = me.chart.surface.add({
+                        type: 'path',
+                        path: path,
+                        "stroke-width": me.lineWidth || 1,
+                        stroke: me.gridColor || '#ccc'
+                    });
+                }
+                me.gridLines.setAttributes({
+                    hidden: false,
+                    path: path
+                }, true);
+            }
+            else if (me.gridLines) {
+                me.gridLines.hide(true);
+            }
+        }
+    },
+
+    
+    getOrCreateLabel: function (i, text) {
+        var me = this,
+            labelGroup = me.labelGroup,
+            textLabel = labelGroup.getAt(i),
+            surface = me.chart.surface;
+        if (textLabel) {
+            if (text != textLabel.attr.text) {
+                textLabel.setAttributes(Ext.apply({
+                    text: text
+                }, me.label), true);
+                textLabel._bbox = textLabel.getBBox();
+            }
+        }
+        else {
+            textLabel = surface.add(Ext.apply({
+                group: labelGroup,
+                type: 'text',
+                x: 0,
+                y: 0,
+                text: text
+            }, me.label));
+            surface.renderItem(textLabel);
+            textLabel._bbox = textLabel.getBBox();
+        }
+        
+        if (me.label.rotation) {
+            textLabel.setAttributes({
+                rotation: {
+                    degrees: 0
+                }
+            }, true);
+            textLabel._ubbox = textLabel.getBBox();
+            textLabel.setAttributes(me.label, true);
+        } else {
+            textLabel._ubbox = textLabel._bbox;
+        }
+        return textLabel;
+    },
+
+    rect2pointArray: function (sprite) {
+        var surface = this.chart.surface,
+            rect = surface.getBBox(sprite, true),
+            p1 = [rect.x, rect.y],
+            p1p = p1.slice(),
+            p2 = [rect.x + rect.width, rect.y],
+            p2p = p2.slice(),
+            p3 = [rect.x + rect.width, rect.y + rect.height],
+            p3p = p3.slice(),
+            p4 = [rect.x, rect.y + rect.height],
+            p4p = p4.slice(),
+            matrix = sprite.matrix;
+        
+        p1[0] = matrix.x.apply(matrix, p1p);
+        p1[1] = matrix.y.apply(matrix, p1p);
+
+        p2[0] = matrix.x.apply(matrix, p2p);
+        p2[1] = matrix.y.apply(matrix, p2p);
+
+        p3[0] = matrix.x.apply(matrix, p3p);
+        p3[1] = matrix.y.apply(matrix, p3p);
+
+        p4[0] = matrix.x.apply(matrix, p4p);
+        p4[1] = matrix.y.apply(matrix, p4p);
+        return [p1, p2, p3, p4];
+    },
+
+    intersect: function (l1, l2) {
+        var r1 = this.rect2pointArray(l1),
+            r2 = this.rect2pointArray(l2);
+        return !!Ext.draw.Draw.intersect(r1, r2).length;
+    },
+
+    drawHorizontalLabels: function () {
+        var me = this,
+            labelConf = me.label,
+            floor = Math.floor,
+            max = Math.max,
+            axes = me.chart.axes,
+            insetPadding = me.chart.insetPadding,
+            position = me.position,
+            inflections = me.inflections,
+            ln = inflections.length,
+            labels = me.labels,
+            maxHeight = 0,
+            ratio,
+            bbox, point, prevLabel, prevLabelId,
+            adjustEnd = me.adjustEnd,
+            hasLeft = axes.findIndex('position', 'left') != -1,
+            hasRight = axes.findIndex('position', 'right') != -1,
+            textLabel, text,
+            last, x, y, i, firstLabel;
+
+        last = ln - 1;
+        
+        point = inflections[0];
+        firstLabel = me.getOrCreateLabel(0, me.label.renderer(labels[0]));
+        ratio = Math.floor(Math.abs(Math.sin(labelConf.rotate && (labelConf.rotate.degrees * Math.PI / 180) || 0)));
+
+        for (i = 0; i < ln; i++) {
+            point = inflections[i];
+            text = me.label.renderer(labels[i]);
+            textLabel = me.getOrCreateLabel(i, text);
+            bbox = textLabel._bbox;
+            maxHeight = max(maxHeight, bbox.height + me.dashSize + me.label.padding);
+            x = floor(point[0] - (ratio ? bbox.height : bbox.width) / 2);
+            if (adjustEnd && me.chart.maxGutter[0] == 0) {
+                if (i == 0 && !hasLeft) {
+                    x = point[0];
+                }
+                else if (i == last && !hasRight) {
+                    x = Math.min(x, point[0] - bbox.width + insetPadding);
+                }
+            }
+            if (position == 'top') {
+                y = point[1] - (me.dashSize * 2) - me.label.padding - (bbox.height / 2);
+            }
+            else {
+                y = point[1] + (me.dashSize * 2) + me.label.padding + (bbox.height / 2);
+            }
+
+            textLabel.setAttributes({
+                hidden: false,
+                x: x,
+                y: y
+            }, true);
+
+            
+            if (i != 0 && (me.intersect(textLabel, prevLabel)
+                || me.intersect(textLabel, firstLabel))) {
+                if (i === last && prevLabelId !== 0) {
+                    prevLabel.hide(true);
+                } else {
+                    textLabel.hide(true);
+                    continue;
+                }
+            }
+
+            prevLabel = textLabel;
+            prevLabelId = i;
+        }
+
+        return maxHeight;
+    },
+
+    drawVerticalLabels: function () {
+        var me = this,
+            inflections = me.inflections,
+            position = me.position,
+            ln = inflections.length,
+            chart = me.chart,
+            insetPadding = chart.insetPadding,
+            labels = me.labels,
+            maxWidth = 0,
+            max = Math.max,
+            floor = Math.floor,
+            ceil = Math.ceil,
+            axes = me.chart.axes,
+            gutterY = me.chart.maxGutter[1],
+            bbox, point, prevLabel, prevLabelId,
+            hasTop = axes.findIndex('position', 'top') != -1,
+            hasBottom = axes.findIndex('position', 'bottom') != -1,
+            adjustEnd = me.adjustEnd,
+            textLabel, text,
+            last = ln - 1, x, y, i;
+
+        for (i = 0; i < ln; i++) {
+            point = inflections[i];
+            text = me.label.renderer(labels[i]);
+            textLabel = me.getOrCreateLabel(i, text);
+            bbox = textLabel._bbox;
+
+            maxWidth = max(maxWidth, bbox.width + me.dashSize + me.label.padding);
+            y = point[1];
+            if (adjustEnd && gutterY < bbox.height / 2) {
+                if (i == last && !hasTop) {
+                    y = Math.max(y, me.y - me.length + ceil(bbox.height / 2) - insetPadding);
+                }
+                else if (i == 0 && !hasBottom) {
+                    y = me.y + gutterY - floor(bbox.height / 2);
+                }
+            }
+            if (position == 'left') {
+                x = point[0] - bbox.width - me.dashSize - me.label.padding - 2;
+            }
+            else {
+                x = point[0] + me.dashSize + me.label.padding + 2;
+            }
+            textLabel.setAttributes(Ext.apply({
+                hidden: false,
+                x: x,
+                y: y
+            }, me.label), true);
+            
+            if (i != 0 && me.intersect(textLabel, prevLabel)) {
+                if (i === last && prevLabelId !== 0) {
+                    prevLabel.hide(true);
+                } else {
+                    textLabel.hide(true);
+                    continue;
+                }
+            }
+            prevLabel = textLabel;
+            prevLabelId = i;
+        }
+
+        return maxWidth;
+    },
+
+    
+    drawLabel: function () {
+        var me = this,
+            position = me.position,
+            labelGroup = me.labelGroup,
+            inflections = me.inflections,
+            maxWidth = 0,
+            maxHeight = 0,
+            ln, i;
+
+        if (position == 'left' || position == 'right') {
+            maxWidth = me.drawVerticalLabels();
+        } else {
+            maxHeight = me.drawHorizontalLabels();
+        }
+
+        
+        ln = labelGroup.getCount();
+        i = inflections.length;
+        for (; i < ln; i++) {
+            labelGroup.getAt(i).hide(true);
+        }
+
+        me.bbox = {};
+        Ext.apply(me.bbox, me.axisBBox);
+        me.bbox.height = maxHeight;
+        me.bbox.width = maxWidth;
+        if (Ext.isString(me.title)) {
+            me.drawTitle(maxWidth, maxHeight);
+        }
+    },
+
+    
+    setTitle: function (title) {
+        this.title = title;
+        this.drawLabel();
+    },
+
+    
+    drawTitle: function (maxWidth, maxHeight) {
+        var me = this,
+            position = me.position,
+            surface = me.chart.surface,
+            displaySprite = me.displaySprite,
+            title = me.title,
+            rotate = (position == 'left' || position == 'right'),
+            x = me.x,
+            y = me.y,
+            base, bbox, pad;
+
+        if (displaySprite) {
+            displaySprite.setAttributes({text: title}, true);
+        } else {
+            base = {
+                type: 'text',
+                x: 0,
+                y: 0,
+                text: title
+            };
+            displaySprite = me.displaySprite = surface.add(Ext.apply(base, me.axisTitleStyle, me.labelTitle));
+            surface.renderItem(displaySprite);
+        }
+        bbox = displaySprite.getBBox();
+        pad = me.dashSize + me.label.padding;
+
+        if (rotate) {
+            y -= ((me.length / 2) - (bbox.height / 2));
+            if (position == 'left') {
+                x -= (maxWidth + pad + (bbox.width / 2));
+            }
+            else {
+                x += (maxWidth + pad + bbox.width - (bbox.width / 2));
+            }
+            me.bbox.width += bbox.width + 10;
+        }
+        else {
+            x += (me.length / 2) - (bbox.width * 0.5);
+            if (position == 'top') {
+                y -= (maxHeight + pad + (bbox.height * 0.3));
+            }
+            else {
+                y += (maxHeight + pad + (bbox.height * 0.8));
+            }
+            me.bbox.height += bbox.height + 10;
+        }
+        displaySprite.setAttributes({
+            translate: {
+                x: x,
+                y: y
+            }
+        }, true);
+    }
+});
+
+
+Ext.define('Ext.chart.axis.Category', {
+
+    
+
+    extend: 'Ext.chart.axis.Axis',
+
+    alternateClassName: 'Ext.chart.CategoryAxis',
+
+    alias: 'axis.category',
+
+    
+
+    
+    categoryNames: null,
+
+    
+    calculateCategoryCount: false,
+
+    
+    setLabels: function() {
+        var store = this.chart.getChartStore(),
+            data = store.data.items,
+            d, dLen, record,
+            fields = this.fields,
+            ln = fields.length,
+            i;
+
+        this.labels = [];
+        for (d = 0, dLen = data.length; d < dLen; d++) {
+            record = data[d];
+            for (i = 0; i < ln; i++) {
+                this.labels.push(record.get(fields[i]));
+            }
+        }
+    },
+
+    
+    applyData: function() {
+        this.callParent();
+        this.setLabels();
+        var count = this.chart.getChartStore().getCount();
+        return {
+            from: 0,
+            to: count - 1,
+            power: 1,
+            step: 1,
+            steps: count - 1
+        };
+    }
+});
+
+
+Ext.define('Ext.chart.axis.Gauge', {
+
+    
+
+    extend: 'Ext.chart.axis.Abstract',
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    position: 'gauge',
+
+    alias: 'axis.gauge',
+
+    drawAxis: function(init) {
+        var chart = this.chart,
+            surface = chart.surface,
+            bbox = chart.chartBBox,
+            centerX = bbox.x + (bbox.width / 2),
+            centerY = bbox.y + bbox.height,
+            margin = this.margin || 10,
+            rho = Math.min(bbox.width, 2 * bbox.height) /2 + margin,
+            sprites = [], sprite,
+            steps = this.steps,
+            i, pi = Math.PI,
+            cos = Math.cos,
+            sin = Math.sin;
+
+        if (this.sprites && !chart.resizing) {
+            this.drawLabel();
+            return;
+        }
+
+        if (this.margin >= 0) {
+            if (!this.sprites) {
+                
+                for (i = 0; i <= steps; i++) {
+                    sprite = surface.add({
+                        type: 'path',
+                        path: ['M', centerX + (rho - margin) * cos(i / steps * pi - pi),
+                                    centerY + (rho - margin) * sin(i / steps * pi - pi),
+                                    'L', centerX + rho * cos(i / steps * pi - pi),
+                                    centerY + rho * sin(i / steps * pi - pi), 'Z'],
+                        stroke: '#ccc'
+                    });
+                    sprite.setAttributes({
+                        hidden: false
+                    }, true);
+                    sprites.push(sprite);
+                }
+            } else {
+                sprites = this.sprites;
+                
+                for (i = 0; i <= steps; i++) {
+                    sprites[i].setAttributes({
+                        path: ['M', centerX + (rho - margin) * cos(i / steps * pi - pi),
+                                    centerY + (rho - margin) * sin(i / steps * pi - pi),
+                               'L', centerX + rho * cos(i / steps * pi - pi),
+                                    centerY + rho * sin(i / steps * pi - pi), 'Z'],
+                        stroke: '#ccc'
+                    }, true);
+                }
+            }
+        }
+        this.sprites = sprites;
+        this.drawLabel();
+        if (this.title) {
+            this.drawTitle();
+        }
+    },
+
+    drawTitle: function() {
+        var me = this,
+            chart = me.chart,
+            surface = chart.surface,
+            bbox = chart.chartBBox,
+            labelSprite = me.titleSprite,
+            labelBBox;
+
+        if (!labelSprite) {
+            me.titleSprite = labelSprite = surface.add({
+                type: 'text',
+                zIndex: 2
+            });
+        }
+        labelSprite.setAttributes(Ext.apply({
+            text: me.title
+        }, me.label || {}), true);
+        labelBBox = labelSprite.getBBox();
+        labelSprite.setAttributes({
+            x: bbox.x + (bbox.width / 2) - (labelBBox.width / 2),
+            y: bbox.y + bbox.height - (labelBBox.height / 2) - 4
+        }, true);
+    },
+
+    
+    setTitle: function(title) {
+        this.title = title;
+        this.drawTitle();
+    },
+
+    drawLabel: function() {
+        var chart = this.chart,
+            surface = chart.surface,
+            bbox = chart.chartBBox,
+            centerX = bbox.x + (bbox.width / 2),
+            centerY = bbox.y + bbox.height,
+            margin = this.margin || 10,
+            rho = Math.min(bbox.width, 2 * bbox.height) /2 + 2 * margin,
+            round = Math.round,
+            labelArray = [], label,
+            maxValue = this.maximum || 0,
+            minValue = this.minimum || 0,
+            steps = this.steps, i = 0,
+            adjY,
+            pi = Math.PI,
+            cos = Math.cos,
+            sin = Math.sin,
+            labelConf = this.label,
+            renderer = labelConf.renderer || function(v) { return v; };
+
+        if (!this.labelArray) {
+            
+            for (i = 0; i <= steps; i++) {
+                
+                adjY = (i === 0 || i === steps) ? 7 : 0;
+                label = surface.add({
+                    type: 'text',
+                    text: renderer(round(minValue + i / steps * (maxValue - minValue))),
+                    x: centerX + rho * cos(i / steps * pi - pi),
+                    y: centerY + rho * sin(i / steps * pi - pi) - adjY,
+                    'text-anchor': 'middle',
+                    'stroke-width': 0.2,
+                    zIndex: 10,
+                    stroke: '#333'
+                });
+                label.setAttributes({
+                    hidden: false
+                }, true);
+                labelArray.push(label);
+            }
+        }
+        else {
+            labelArray = this.labelArray;
+            
+            for (i = 0; i <= steps; i++) {
+                
+                adjY = (i === 0 || i === steps) ? 7 : 0;
+                labelArray[i].setAttributes({
+                    text: renderer(round(minValue + i / steps * (maxValue - minValue))),
+                    x: centerX + rho * cos(i / steps * pi - pi),
+                    y: centerY + rho * sin(i / steps * pi - pi) - adjY
+                }, true);
+            }
+        }
+        this.labelArray = labelArray;
+    }
+});
+
+
+Ext.define('Ext.chart.axis.Numeric', {
+
+    
+
+    extend: 'Ext.chart.axis.Axis',
+
+    alternateClassName: 'Ext.chart.NumericAxis',
+
+    
+
+    type: 'numeric',
+
+    alias: 'axis.numeric',
+
+    uses: ['Ext.data.Store'],
+
+    constructor: function(config) {
+        var me = this,
+            hasLabel = !!(config.label && config.label.renderer),
+            label;
+
+        me.callParent([config]);
+        label = me.label;
+
+        if (config.constrain == null) {
+            me.constrain = (config.minimum != null && config.maximum != null);
+        }
+
+        if (!hasLabel) {
+            label.renderer = function(v) {
+                return me.roundToDecimal(v, me.decimals);
+            };
+        }
+    },
+
+    roundToDecimal: function(v, dec) {
+        var val = Math.pow(10, dec || 0);
+        return Math.round(v * val) / val;
+    },
+
+    
+    minimum: NaN,
+
+    
+    maximum: NaN,
+
+    
+    constrain: true,
+
+    
+    decimals: 2,
+
+    
+    scale: "linear",
+
+    
+    doConstrain: function() {
+        var me = this,
+            store = me.chart.store,
+            items = store.data.items,
+            d, dLen, record,
+            series = me.chart.series.items,
+            fields = me.fields,
+            ln = fields.length,
+            range = me.calcEnds(),
+            min = range.from, max = range.to, i, l,
+            useAcum = false,
+            value, data = [],
+            addRecord;
+
+        for (i = 0, l = series.length; i < l; i++) {
+            if (series[i].type === 'bar' && series[i].stacked) {
+                
+                return;
+            }
+        }
+
+        for (d = 0, dLen = items.length; d < dLen; d++) {
+            addRecord = true;
+            record = items[d];
+            for (i = 0; i < ln; i++) {
+                value = record.get(fields[i]);
+                if (+value < +min) {
+                    addRecord = false;
+                    break;
+                }
+                if (+value > +max) {
+                    addRecord = false;
+                    break;
+                }
+            }
+            if (addRecord) {
+                data.push(record);
+            }
+        }
+        me.chart.substore = Ext.create('Ext.data.Store', { model: store.model });
+        me.chart.substore.loadData(data); 
+    },
+    
+    position: 'left',
+
+    
+    adjustMaximumByMajorUnit: false,
+
+    
+    adjustMinimumByMajorUnit: false,
+
+    
+    processView: function() {
+        var me = this,
+            constrain = me.constrain;
+        if (constrain) {
+            me.doConstrain();
+        }
+    },
+
+    
+    applyData: function() {
+        this.callParent();
+        return this.calcEnds();
+    }
+});
+
+
+Ext.define('Ext.chart.axis.Radial', {
+
+    
+
+    extend: 'Ext.chart.axis.Abstract',
+
+    
+
+    position: 'radial',
+
+    alias: 'axis.radial',
+
+    drawAxis: function(init) {
+        var chart = this.chart,
+            surface = chart.surface,
+            bbox = chart.chartBBox,
+            store = chart.store,
+            l = store.getCount(),
+            centerX = bbox.x + (bbox.width / 2),
+            centerY = bbox.y + (bbox.height / 2),
+            rho = Math.min(bbox.width, bbox.height) /2,
+            sprites = [], sprite,
+            steps = this.steps,
+            i, j, pi2 = Math.PI * 2,
+            cos = Math.cos, sin = Math.sin;
+
+        if (this.sprites && !chart.resizing) {
+            this.drawLabel();
+            return;
+        }
+
+        if (!this.sprites) {
+            
+            for (i = 1; i <= steps; i++) {
+                sprite = surface.add({
+                    type: 'circle',
+                    x: centerX,
+                    y: centerY,
+                    radius: Math.max(rho * i / steps, 0),
+                    stroke: '#ccc'
+                });
+                sprite.setAttributes({
+                    hidden: false
+                }, true);
+                sprites.push(sprite);
+            }
+            
+            for (i = 0; i < l; i++) {
+                sprite = surface.add({
+                    type: 'path',
+                    path: ['M', centerX, centerY, 'L', centerX + rho * cos(i / l * pi2), centerY + rho * sin(i / l * pi2), 'Z'],
+                    stroke: '#ccc'
+                });
+                sprite.setAttributes({
+                    hidden: false
+                }, true);
+                sprites.push(sprite);
+            }
+        } else {
+            sprites = this.sprites;
+            
+            for (i = 0; i < steps; i++) {
+                sprites[i].setAttributes({
+                    x: centerX,
+                    y: centerY,
+                    radius: Math.max(rho * (i + 1) / steps, 0),
+                    stroke: '#ccc'
+                }, true);
+            }
+            
+            for (j = 0; j < l; j++) {
+                sprites[i + j].setAttributes({
+                    path: ['M', centerX, centerY, 'L', centerX + rho * cos(j / l * pi2), centerY + rho * sin(j / l * pi2), 'Z'],
+                    stroke: '#ccc'
+                }, true);
+            }
+        }
+        this.sprites = sprites;
+
+        this.drawLabel();
+    },
+
+    drawLabel: function() {
+        var chart = this.chart,
+            seriesItems = chart.series.items,
+            series,
+            surface = chart.surface,
+            bbox = chart.chartBBox,
+            store = chart.store,
+            data = store.data.items,
+            ln, record,
+            centerX = bbox.x + (bbox.width / 2),
+            centerY = bbox.y + (bbox.height / 2),
+            rho = Math.min(bbox.width, bbox.height) /2,
+            max = Math.max, round = Math.round,
+            labelArray = [], label,
+            fields = [], nfields,
+            categories = [], xField,
+            aggregate = !this.maximum,
+            maxValue = this.maximum || 0,
+            steps = this.steps, i = 0, j, dx, dy,
+            pi2 = Math.PI * 2,
+            cos = Math.cos, sin = Math.sin,
+            display = this.label.display,
+            draw = display !== 'none',
+            margin = 10;
+
+        if (!draw) {
+            return;
+        }
+
+        
+        for (i = 0, ln = seriesItems.length; i < ln; i++) {
+            series = seriesItems[i];
+            fields.push(series.yField);
+            xField = series.xField;
+        }
+        
+        
+        for (j = 0, ln = data.length; j < ln; j++) {
+            record = data[j];
+            if (aggregate) {
+                for (i = 0, nfields = fields.length; i < nfields; i++) {
+                    maxValue = max(+record.get(fields[i]), maxValue);
+                }
+            }
+            categories.push(record.get(xField));
+        }
+        if (!this.labelArray) {
+            if (display != 'categories') {
+                
+                for (i = 1; i <= steps; i++) {
+                    label = surface.add({
+                        type: 'text',
+                        text: round(i / steps * maxValue),
+                        x: centerX,
+                        y: centerY - rho * i / steps,
+                        'text-anchor': 'middle',
+                        'stroke-width': 0.1,
+                        stroke: '#333'
+                    });
+                    label.setAttributes({
+                        hidden: false
+                    }, true);
+                    labelArray.push(label);
+                }
+            }
+            if (display != 'scale') {
+                
+                for (j = 0, steps = categories.length; j < steps; j++) {
+                    dx = cos(j / steps * pi2) * (rho + margin);
+                    dy = sin(j / steps * pi2) * (rho + margin);
+                    label = surface.add({
+                        type: 'text',
+                        text: categories[j],
+                        x: centerX + dx,
+                        y: centerY + dy,
+                        'text-anchor': dx * dx <= 0.001? 'middle' : (dx < 0? 'end' : 'start')
+                    });
+                    label.setAttributes({
+                        hidden: false
+                    }, true);
+                    labelArray.push(label);
+                }
+            }
+        }
+        else {
+            labelArray = this.labelArray;
+            if (display != 'categories') {
+                
+                for (i = 0; i < steps; i++) {
+                    labelArray[i].setAttributes({
+                        text: round((i + 1) / steps * maxValue),
+                        x: centerX,
+                        y: centerY - rho * (i + 1) / steps,
+                        'text-anchor': 'middle',
+                        'stroke-width': 0.1,
+                        stroke: '#333'
+                    }, true);
+                }
+            }
+            if (display != 'scale') {
+                
+                for (j = 0, steps = categories.length; j < steps; j++) {
+                    dx = cos(j / steps * pi2) * (rho + margin);
+                    dy = sin(j / steps * pi2) * (rho + margin);
+                    if (labelArray[i + j]) {
+                        labelArray[i + j].setAttributes({
+                            type: 'text',
+                            text: categories[j],
+                            x: centerX + dx,
+                            y: centerY + dy,
+                            'text-anchor': dx * dx <= 0.001? 'middle' : (dx < 0? 'end' : 'start')
+                        }, true);
+                    }
+                }
+            }
+        }
+        this.labelArray = labelArray;
+    }
+});
+
+
+Ext.define('Ext.chart.axis.Time', {
+
+    
+
+    extend: 'Ext.chart.axis.Numeric',
+
+    alternateClassName: 'Ext.chart.TimeAxis',
+
+    alias: 'axis.time',
+
+    uses: ['Ext.data.Store'],
+
+    
+
+    
+    dateFormat: false,
+
+    
+    fromDate: false,
+
+    
+    toDate: false,
+
+    
+    step: [Ext.Date.DAY, 1],
+
+    
+    constrain: false,
+
+    constructor: function (config) {
+        var me = this, label, f, df;
+        me.callParent([config]);
+        label = me.label || {};
+        df = this.dateFormat;
+        if (df) {
+            if (label.renderer) {
+                f = label.renderer;
+                label.renderer = function(v) {
+                    v = f(v);
+                    return Ext.Date.format(new Date(f(v)), df);
+                };
+            } else {
+                label.renderer = function(v) {
+                    return Ext.Date.format(new Date(v >> 0), df);
+                };
+            }
+        }
+    },
+
+    
+    processView: function () {
+        var me = this;
+        if (me.fromDate) {
+            me.minimum = +me.fromDate;
+        }
+        if (me.toDate) {
+            me.maximum = +me.toDate;
+        }
+        if(me.constrain){
+            me.doConstrain();
+        }
+     },
+
+    
+    calcEnds: function() {
+        var me = this, range, step = me.step;
+        if (step) {
+            range = me.getRange();
+            range = Ext.draw.Draw.snapEndsByDateAndStep(new Date(range.min), new Date(range.max), Ext.isNumber(step) ? [Date.MILLI, step]: step);
+            if (me.minimum) {
+                range.from = me.minimum;
+            }
+            if (me.maximum) {
+                range.to = me.maximum;
+            }
+            range.step = (range.to - range.from) / range.steps;
+            return range;
+        } else {
+            return me.callParent(arguments);
+        }
+    }
+ });
+
+
+
+Ext.define('Ext.chart.series.Series', {
+
+    
+
+    mixins: {
+        observable: 'Ext.util.Observable',
+        labels: 'Ext.chart.Label',
+        highlights: 'Ext.chart.Highlight',
+        tips: 'Ext.chart.Tip',
+        callouts: 'Ext.chart.Callout'
+    },
+
+    
+
+    
+
+    
+
+    
+    type: null,
+
+    
+    title: null,
+
+    
+    showInLegend: true,
+
+    
+    renderer: function(sprite, record, attributes, index, store) {
+        return attributes;
+    },
+
+    
+    shadowAttributes: null,
+
+    
+    animating: false,
+
+    
+
+    constructor: function(config) {
+        var me = this;
+        if (config) {
+            Ext.apply(me, config);
+        }
+
+        me.shadowGroups = [];
+
+        me.mixins.labels.constructor.call(me, config);
+        me.mixins.highlights.constructor.call(me, config);
+        me.mixins.tips.constructor.call(me, config);
+        me.mixins.callouts.constructor.call(me, config);
+
+        me.addEvents({
+            scope: me,
+            itemmouseover: true,
+            itemmouseout: true,
+            itemmousedown: true,
+            itemmouseup: true,
+            mouseleave: true,
+            afterdraw: true,
+
+            
+            titlechange: true
+        });
+
+        me.mixins.observable.constructor.call(me, config);
+
+        me.on({
+            scope: me,
+            itemmouseover: me.onItemMouseOver,
+            itemmouseout: me.onItemMouseOut,
+            mouseleave: me.onMouseLeave
+        });
+        
+        if (me.style) {
+            Ext.apply(me.seriesStyle, me.style);
+        }
+    },
+    
+    
+    eachRecord: function(fn, scope) {
+        var chart = this.chart;
+        (chart.substore || chart.store).each(fn, scope);
+    },
+
+    
+    getRecordCount: function() {
+        var chart = this.chart,
+            store = chart.substore || chart.store;
+        return store ? store.getCount() : 0;
+    },
+
+    
+    isExcluded: function(index) {
+        var excludes = this.__excludes;
+        return !!(excludes && excludes[index]);
+    },
+
+    
+    setBBox: function(noGutter) {
+        var me = this,
+            chart = me.chart,
+            chartBBox = chart.chartBBox,
+            gutterX = noGutter ? 0 : chart.maxGutter[0],
+            gutterY = noGutter ? 0 : chart.maxGutter[1],
+            clipBox, bbox;
+
+        clipBox = {
+            x: chartBBox.x,
+            y: chartBBox.y,
+            width: chartBBox.width,
+            height: chartBBox.height
+        };
+        me.clipBox = clipBox;
+
+        bbox = {
+            x: (clipBox.x + gutterX) - (chart.zoom.x * chart.zoom.width),
+            y: (clipBox.y + gutterY) - (chart.zoom.y * chart.zoom.height),
+            width: (clipBox.width - (gutterX * 2)) * chart.zoom.width,
+            height: (clipBox.height - (gutterY * 2)) * chart.zoom.height
+        };
+        me.bbox = bbox;
+    },
+
+    
+    onAnimate: function(sprite, attr) {
+        var me = this;
+        sprite.stopAnimation();
+        if (me.animating) {
+            return sprite.animate(Ext.applyIf(attr, me.chart.animate));
+        } else {
+            me.animating = true;
+            return sprite.animate(Ext.apply(Ext.applyIf(attr, me.chart.animate), {
+                listeners: {
+                    'afteranimate': function() {
+                        me.animating = false;
+                        me.fireEvent('afterrender');
+                    }
+                }
+            }));
+        }
+    },
+
+    
+    getGutters: function() {
+        return [0, 0];
+    },
+
+    
+    onItemMouseOver: function(item) {
+        var me = this;
+        if (item.series === me) {
+            if (me.highlight) {
+                me.highlightItem(item);
+            }
+            if (me.tooltip) {
+                me.showTip(item);
+            }
+        }
+    },
+
+    
+    onItemMouseOut: function(item) {
+        var me = this;
+        if (item.series === me) {
+            me.unHighlightItem();
+            if (me.tooltip) {
+                me.hideTip(item);
+            }
+        }
+    },
+
+    
+    onMouseLeave: function() {
+        var me = this;
+        me.unHighlightItem();
+        if (me.tooltip) {
+            me.hideTip();
+        }
+    },
+
+    
+    getItemForPoint: function(x, y) {
+        
+        if (!this.items || !this.items.length || this.seriesIsHidden) {
+            return null;
+        }
+        var me = this,
+            items = me.items,
+            bbox = me.bbox,
+            item, i, ln;
+        
+        if (!Ext.draw.Draw.withinBox(x, y, bbox)) {
+            return null;
+        }
+        for (i = 0, ln = items.length; i < ln; i++) {
+            if (items[i] && this.isItemInPoint(x, y, items[i], i)) {
+                return items[i];
+            }
+        }
+
+        return null;
+    },
+
+    isItemInPoint: function(x, y, item, i) {
+        return false;
+    },
+
+    
+    hideAll: function() {
+        var me = this,
+            items = me.items,
+            item, len, i, j, l, sprite, shadows;
+
+        me.seriesIsHidden = true;
+        me._prevShowMarkers = me.showMarkers;
+
+        me.showMarkers = false;
+        
+        me.hideLabels(0);
+        
+        for (i = 0, len = items.length; i < len; i++) {
+            item = items[i];
+            sprite = item.sprite;
+            if (sprite) {
+                sprite.setAttributes({
+                    hidden: true
+                }, true);
+            }
+
+            if (sprite && sprite.shadows) {
+                shadows = sprite.shadows;
+                for (j = 0, l = shadows.length; j < l; ++j) {
+                    shadows[j].setAttributes({
+                        hidden: true
+                    }, true);
+                }
+            }
+        }
+    },
+
+    
+    showAll: function() {
+        var me = this,
+            prevAnimate = me.chart.animate;
+        me.chart.animate = false;
+        me.seriesIsHidden = false;
+        me.showMarkers = me._prevShowMarkers;
+        me.drawSeries();
+        me.chart.animate = prevAnimate;
+    },
+    
+    hide: function() {
+        if (this.items) {
+            var me = this,
+                items = me.items,
+                i, j, lsh, ln, shadows;
+            
+            if (items && items.length) {
+                for (i = 0, ln = items.length; i < ln; ++i) {
+                    if (items[i].sprite) {
+                        items[i].sprite.hide(true);
+
+                        shadows = items[i].shadows || items[i].sprite.shadows;
+                        if (shadows) {
+                            for (j = 0, lsh = shadows.length; j < lsh; ++j) {
+                                shadows[j].hide(true);
+                            }
+                        }
+                    }
+                }
+                me.hideLabels();
+            }
+        }
+    },
+
+    
+    getLegendColor: function(index) {
+        var me = this, fill, stroke;
+        if (me.seriesStyle) {
+            fill = me.seriesStyle.fill;
+            stroke = me.seriesStyle.stroke;
+            if (fill && fill != 'none') {
+                return fill;
+            }
+            if(stroke){
+                return stroke;
+            }
+        }
+        return (me.colorArrayStyle)?me.colorArrayStyle[me.seriesIdx % me.colorArrayStyle.length]:'#000';
+    },
+
+    
+    visibleInLegend: function(index){
+        var excludes = this.__excludes;
+        if (excludes) {
+            return !excludes[index];
+        }
+        return !this.seriesIsHidden;
+    },
+
+    
+    setTitle: function(index, title) {
+        var me = this,
+            oldTitle = me.title;
+
+        if (Ext.isString(index)) {
+            title = index;
+            index = 0;
+        }
+
+        if (Ext.isArray(oldTitle)) {
+            oldTitle[index] = title;
+        } else {
+            me.title = title;
+        }
+
+        me.fireEvent('titlechange', title, index);
+    }
+});
+
+
+Ext.define('Ext.chart.series.Cartesian', {
+
+    
+
+    extend: 'Ext.chart.series.Series',
+
+    alternateClassName: ['Ext.chart.CartesianSeries', 'Ext.chart.CartesianChart'],
+
+    
+
+    
+    xField: null,
+
+    
+    yField: null,
+
+    
+    axis: 'left',
+
+    getLegendLabels: function() {
+        var me = this,
+            labels = [],
+            fields, i, ln,
+            combinations = me.combinations,
+            title,
+            combo, label0, label1;
+
+        fields = [].concat(me.yField);
+        for (i = 0, ln = fields.length; i < ln; i++) {
+            title = me.title;
+            
+            labels.push((Ext.isArray(title) ? title[i] : title) || fields[i]);
+        }
+
+        
+        
+        if (combinations) {
+            combinations = Ext.Array.from(combinations);
+            for (i = 0, ln = combinations.length; i < ln; i++) {
+                combo = combinations[i];
+                label0 = labels[combo[0]];
+                label1 = labels[combo[1]];
+                labels[combo[1]] = label0 + ' & ' + label1;
+                labels.splice(combo[0], 1);
+            }
+        }
+
+        return labels;
+    },
+
+    
+    eachYValue: function(record, fn, scope) {
+        var me = this,
+            yValueAccessors = me.getYValueAccessors(),
+            i, ln, accessor;
+        
+        for (i = 0, ln = yValueAccessors.length; i < ln; i++) {
+            accessor = yValueAccessors[i];
+            fn.call(scope, accessor(record), i);
+        }
+    },
+
+    
+    getYValueCount: function() {
+        return this.getYValueAccessors().length;
+    },
+
+    combine: function(index1, index2) {
+        var me = this,
+            accessors = me.getYValueAccessors(),
+            accessor1 = accessors[index1],
+            accessor2 = accessors[index2];
+
+        
+        accessors[index2] = function(record) {
+            return accessor1(record) + accessor2(record);
+        };
+        accessors.splice(index1, 1);
+
+        me.callParent([index1, index2]);
+    },
+
+    clearCombinations: function() {
+        
+        delete this.yValueAccessors;
+        this.callParent();
+    },
+
+    
+    getYValueAccessors: function() {
+        var me = this,
+            accessors = me.yValueAccessors,
+            yFields, yField, i, ln;
+        if (!accessors) {
+            accessors = me.yValueAccessors = [];
+            yFields = [].concat(me.yField);
+            
+            for (i = 0, ln = yFields.length; i < ln; i++) {
+                yField = yFields[i];
+                accessors.push(function(record) {
+                    return record.get(yField);
+                });
+            }
+        }
+        return accessors;
+    },
+
+    
+    getMinMaxXValues: function() {
+        var me = this,
+            chart = me.chart,
+            store = chart.getChartStore(),
+            data = store.data.items,
+            i, ln, record,
+            min, max,
+            xField = me.xField,
+            xValue;
+
+        if (me.getRecordCount() > 0) {
+            min = Infinity;
+            max = -min;
+                
+            for (i = 0, ln = data.length; i < ln; i++) {
+                record = data[i];
+                xValue = record.get(xField);
+                if (xValue > max) {
+                    max = xValue;
+                }
+                if (xValue < min) {
+                    min = xValue;
+                }
+            }
+        } else {
+            min = max = 0;
+        }
+        return [min, max];
+    },
+
+    
+    getMinMaxYValues: function() {
+        var me = this,
+            chart = me.chart,
+            store = chart.getChartStore(),
+            data = store.data.items,
+            i, ln, record,
+            stacked = me.stacked,
+            min, max,
+            positiveTotal, negativeTotal;
+
+        function eachYValueStacked(yValue, i) {
+            if (!me.isExcluded(i)) {
+                if (yValue < 0) {
+                    negativeTotal += yValue;
+                } else {
+                    positiveTotal += yValue;
+                }
+            }
+        }
+
+        function eachYValue(yValue, i) {
+            if (!me.isExcluded(i)) {
+                if (yValue > max) {
+                    max = yValue;
+                }
+                if (yValue < min) {
+                    min = yValue;
+                }
+            }
+        }
+
+        if (me.getRecordCount() > 0) {
+            min = Infinity;
+            max = -min;
+            
+            for (i = 0, ln = data.length; i < ln; i++) {
+                record = data[i];
+                if (stacked) {
+                    positiveTotal = 0;
+                    negativeTotal = 0;
+                    me.eachYValue(record, eachYValueStacked);
+                    if (positiveTotal > max) {
+                        max = positiveTotal;
+                    }
+                    if (negativeTotal < min) {
+                        min = negativeTotal;
+                    }
+                } else {
+                    me.eachYValue(record, eachYValue);
+                }
+            }
+        } else {
+            min = max = 0;
+        }
+        return [min, max];
+    },
+
+    getAxesForXAndYFields: function() {
+        var me = this,
+            axes = me.chart.axes,
+            axis = [].concat(me.axis),
+            yFields = {}, yFieldList = [].concat(me.yField),
+            xFields = {}, xFieldList = [].concat(me.xField),
+            fields, xAxis, yAxis, i, ln, flipXY;
+
+        
+        flipXY = me.type === 'bar' && me.column === false;
+        if(flipXY) {
+            fields = yFieldList;
+            yFieldList = xFieldList;
+            xFieldList = fields;
+        }
+        if (Ext.Array.indexOf(axis, 'top') > -1) {
+            xAxis = 'top';
+        } else if (Ext.Array.indexOf(axis, 'bottom') > -1) {
+            xAxis = 'bottom';
+        } else {
+            if (axes.get('top') && axes.get('bottom')) {
+                for (i = 0, ln = xFieldList.length; i < ln; i++) {
+                    xFields[xFieldList[i]] = true;
+                }
+                fields = [].concat(axes.get('bottom').fields);
+                for (i = 0, ln = fields.length; i < ln; i++) {
+                    if (xFields[fields[i]]) {
+                        xAxis = 'bottom';
+                        break
+                    }
+                }
+                fields = [].concat(axes.get('top').fields);
+                for (i = 0, ln = fields.length; i < ln; i++) {
+                    if (xFields[fields[i]]) {
+                        xAxis = 'top';
+                        break
+                    }
+                }
+            } else if (axes.get('top')) {
+                xAxis = 'top';
+            } else if (axes.get('bottom')) {
+                xAxis = 'bottom';
+            }
+        }
+        if (Ext.Array.indexOf(axis, 'left') > -1) {
+            yAxis = 'left';
+        } else if (Ext.Array.indexOf(axis, 'right') > -1) {
+            yAxis = 'right';
+        } else {
+            if (axes.get('left') && axes.get('right')) {
+                for (i = 0, ln = yFieldList.length; i < ln; i++) {
+                    yFields[yFieldList[i]] = true;
+                }
+                fields = [].concat(axes.get('right').fields);
+                for (i = 0, ln = fields.length; i < ln; i++) {
+                    if (yFields[fields[i]]) {
+
+                        break
+                    }
+                }
+                fields = [].concat(axes.get('left').fields);
+                for (i = 0, ln = fields.length; i < ln; i++) {
+                    if (yFields[fields[i]]) {
+                        yAxis = 'left';
+                        break
+                    }
+                }
+            } else if (axes.get('left')) {
+                yAxis = 'left';
+            } else if (axes.get('right')) {
+                yAxis = 'right';
+            }
+        }
+
+        return flipXY ? {
+            xAxis: yAxis,
+            yAxis: xAxis
+        }: {
+            xAxis: xAxis,
+            yAxis: yAxis
+        };
+    }
+
+
+});
+
+
+Ext.define('Ext.chart.series.Area', {
+
+    
+
+    extend: 'Ext.chart.series.Cartesian',
+
+    alias: 'series.area',
+
+    requires: ['Ext.chart.axis.Axis', 'Ext.draw.Color', 'Ext.fx.Anim'],
+
+    
+
+    type: 'area',
+
+    
+    stacked: true,
+
+    
+    style: {},
+
+    constructor: function(config) {
+        this.callParent(arguments);
+        var me = this,
+            surface = me.chart.surface,
+            i, l;
+        config.highlightCfg = Ext.Object.merge({}, {
+            lineWidth: 3,
+            stroke: '#55c',
+            opacity: 0.8,
+            color: '#f00'
+        }, config.highlightCfg);
+
+        Ext.apply(me, config, {
+            __excludes: []
+        });
+        if (me.highlight) {
+            me.highlightSprite = surface.add({
+                type: 'path',
+                path: ['M', 0, 0],
+                zIndex: 1000,
+                opacity: 0.3,
+                lineWidth: 5,
+                hidden: true,
+                stroke: '#444'
+            });
+        }
+        me.group = surface.getGroup(me.seriesId);
+    },
+
+    
+    shrink: function(xValues, yValues, size) {
+        var len = xValues.length,
+            ratio = Math.floor(len / size),
+            i, j,
+            xSum = 0,
+            yCompLen = this.areas.length,
+            ySum = [],
+            xRes = [],
+            yRes = [];
+        
+        for (j = 0; j < yCompLen; ++j) {
+            ySum[j] = 0;
+        }
+        for (i = 0; i < len; ++i) {
+            xSum += +xValues[i];
+            for (j = 0; j < yCompLen; ++j) {
+                ySum[j] += +yValues[i][j];
+            }
+            if (i % ratio == 0) {
+                
+                xRes.push(xSum/ratio);
+                for (j = 0; j < yCompLen; ++j) {
+                    ySum[j] /= ratio;
+                }
+                yRes.push(ySum);
+                
+                xSum = 0;
+                for (j = 0, ySum = []; j < yCompLen; ++j) {
+                    ySum[j] = 0;
+                }
+            }
+        }
+        return {
+            x: xRes,
+            y: yRes
+        };
+    },
+
+    
+    getBounds: function() {
+        var me = this,
+            chart = me.chart,
+            store = chart.getChartStore(),
+            data = store.data.items,
+            i, l, record,
+            areas = [].concat(me.yField),
+            areasLen = areas.length,
+            xValues = [],
+            yValues = [],
+            infinity = Infinity,
+            minX = infinity,
+            minY = infinity,
+            maxX = -infinity,
+            maxY = -infinity,
+            math = Math,
+            mmin = math.min,
+            mmax = math.max,
+            boundAxis = me.getAxesForXAndYFields(),
+            boundXAxis = boundAxis.xAxis,
+            boundYAxis = boundAxis.yAxis,
+            ends, allowDate,
+            bbox, xScale, yScale, xValue, yValue, areaIndex, acumY, ln, sumValues, clipBox, areaElem, axis, out;
+
+        me.setBBox();
+        bbox = me.bbox;
+
+        if (axis = chart.axes.get(boundXAxis)) {
+            if (axis.type === 'Time') {
+                allowDate = true;
+            }
+            ends = axis.applyData();
+            minX = ends.from;
+            maxX = ends.to;
+        }
+
+        if (axis = chart.axes.get(boundYAxis)) {
+            ends = axis.applyData();
+            minY = ends.from;
+            maxY = ends.to;
+        }
+
+        
+        if (me.xField && !Ext.isNumber(minX)) {
+            axis = me.getMinMaxXValues();
+            allowDate = true;
+            minX = axis[0];
+            maxX = axis[1];
+        }
+
+        if (me.yField && !Ext.isNumber(minY)) {
+            axis = me.getMinMaxYValues();
+            minY = axis[0];
+            maxY = axis[1];
+        }
+
+        if (!Ext.isNumber(minY)) {
+            minY = 0;
+        }
+        if (!Ext.isNumber(maxY)) {
+            maxY = 0;
+        }
+
+        for (i = 0, l = data.length; i < l; i++) {
+            record = data[i];
+            xValue = record.get(me.xField);
+            yValue = [];
+            if (typeof xValue != 'number') {
+                if (allowDate) {
+                    xValue = +xValue;
+                } else {
+                    xValue = i;
+                }
+            }
+            xValues.push(xValue);
+            acumY = 0;
+            for (areaIndex = 0; areaIndex < areasLen; areaIndex++) {
+                
+                if (me.__excludes[areaIndex]) {
+                    continue;
+                }
+                areaElem = record.get(areas[areaIndex]);
+                if (typeof areaElem == 'number') {
+                    yValue.push(areaElem);
+                }
+            }
+            yValues.push(yValue);
+        }
+
+        xScale = bbox.width / ((maxX - minX) || 1);
+        yScale = bbox.height / ((maxY - minY) || 1);
+
+        ln = xValues.length;
+        if ((ln > bbox.width) && me.areas) {
+            sumValues = me.shrink(xValues, yValues, bbox.width);
+            xValues = sumValues.x;
+            yValues = sumValues.y;
+        }
+
+        return {
+            bbox: bbox,
+            minX: minX,
+            minY: minY,
+            xValues: xValues,
+            yValues: yValues,
+            xScale: xScale,
+            yScale: yScale,
+            areasLen: areasLen
+        };
+    },
+
+    
+    getPaths: function() {
+        var me = this,
+            chart = me.chart,
+            store = chart.getChartStore(),
+            first = true,
+            bounds = me.getBounds(),
+            bbox = bounds.bbox,
+            items = me.items = [],
+            componentPaths = [],
+            componentPath,
+            count = 0,
+            paths = [],
+            i, ln, x, y, xValue, yValue, acumY, areaIndex, prevAreaIndex, areaElem, path;
+
+        ln = bounds.xValues.length;
+        
+        for (i = 0; i < ln; i++) {
+            xValue = bounds.xValues[i];
+            yValue = bounds.yValues[i];
+            x = bbox.x + (xValue - bounds.minX) * bounds.xScale;
+            acumY = 0;
+            count = 0;
+            for (areaIndex = 0; areaIndex < bounds.areasLen; areaIndex++) {
+                
+                if (me.__excludes[areaIndex]) {
+                    continue;
+                }
+                if (!componentPaths[areaIndex]) {
+                    componentPaths[areaIndex] = [];
+                }
+                areaElem = yValue[count];
+                acumY += areaElem;
+                y = bbox.y + bbox.height - (acumY - bounds.minY) * bounds.yScale;
+                if (!paths[areaIndex]) {
+                    paths[areaIndex] = ['M', x, y];
+                    componentPaths[areaIndex].push(['L', x, y]);
+                } else {
+                    paths[areaIndex].push('L', x, y);
+                    componentPaths[areaIndex].push(['L', x, y]);
+                }
+                if (!items[areaIndex]) {
+                    items[areaIndex] = {
+                        pointsUp: [],
+                        pointsDown: [],
+                        series: me
+                    };
+                }
+                items[areaIndex].pointsUp.push([x, y]);
+                count++;
+            }
+        }
+
+        
+        for (areaIndex = 0; areaIndex < bounds.areasLen; areaIndex++) {
+            
+            if (me.__excludes[areaIndex]) {
+                continue;
+            }
+            path = paths[areaIndex];
+            
+            if (areaIndex == 0 || first) {
+                first = false;
+                path.push('L', x, bbox.y + bbox.height,
+                          'L', bbox.x, bbox.y + bbox.height,
+                          'Z');
+            }
+            
+            else {
+                componentPath = componentPaths[prevAreaIndex];
+                componentPath.reverse();
+                path.push('L', x, componentPath[0][2]);
+                for (i = 0; i < ln; i++) {
+                    path.push(componentPath[i][0],
+                              componentPath[i][1],
+                              componentPath[i][2]);
+                    items[areaIndex].pointsDown[ln -i -1] = [componentPath[i][1], componentPath[i][2]];
+                }
+                path.push('L', bbox.x, path[2], 'Z');
+            }
+            prevAreaIndex = areaIndex;
+        }
+        return {
+            paths: paths,
+            areasLen: bounds.areasLen
+        };
+    },
+
+    
+    drawSeries: function() {
+        var me = this,
+            chart = me.chart,
+            store = chart.getChartStore(),
+            surface = chart.surface,
+            animate = chart.animate,
+            group = me.group,
+            endLineStyle = Ext.apply(me.seriesStyle, me.style),
+            colorArrayStyle = me.colorArrayStyle,
+            colorArrayLength = colorArrayStyle && colorArrayStyle.length || 0,
+            areaIndex, areaElem, paths, path, rendererAttributes;
+        
+        me.unHighlightItem();
+        me.cleanHighlights();
+
+        if (!store || !store.getCount() || me.seriesIsHidden) {
+            me.hide();
+            me.items = [];
+            return;
+        }
+
+        paths = me.getPaths();
+
+        if (!me.areas) {
+            me.areas = [];
+        }
+
+        for (areaIndex = 0; areaIndex < paths.areasLen; areaIndex++) {
+            
+            if (me.__excludes[areaIndex]) {
+                continue;
+            }
+            if (!me.areas[areaIndex]) {
+                me.items[areaIndex].sprite = me.areas[areaIndex] = surface.add(Ext.apply({}, {
+                    type: 'path',
+                    group: group,
+                    
+                    path: paths.paths[areaIndex],
+                    stroke: endLineStyle.stroke || colorArrayStyle[areaIndex % colorArrayLength],
+                    fill: colorArrayStyle[areaIndex % colorArrayLength]
+                }, endLineStyle || {}));
+            }
+            areaElem = me.areas[areaIndex];
+            path = paths.paths[areaIndex];
+            if (animate) {
+                
+                rendererAttributes = me.renderer(areaElem, false, {
+                    path: path,
+                    
+                    fill: colorArrayStyle[areaIndex % colorArrayLength],
+                    stroke: endLineStyle.stroke || colorArrayStyle[areaIndex % colorArrayLength]
+                }, areaIndex, store);
+                
+                me.animation = me.onAnimate(areaElem, {
+                    to: rendererAttributes
+                });
+            } else {
+                rendererAttributes = me.renderer(areaElem, false, {
+                    path: path,
+                    
+                    hidden: false,
+                    fill: colorArrayStyle[areaIndex % colorArrayLength],
+                    stroke: endLineStyle.stroke || colorArrayStyle[areaIndex % colorArrayLength]
+                }, areaIndex, store);
+                me.areas[areaIndex].setAttributes(rendererAttributes, true);
+            }
+        }
+        me.renderLabels();
+        me.renderCallouts();
+    },
+
+    
+    onAnimate: function(sprite, attr) {
+        sprite.show();
+        return this.callParent(arguments);
+    },
+
+    
+    onCreateLabel: function(storeItem, item, i, display) {
+        var me = this,
+            group = me.labelsGroup,
+            config = me.label,
+            bbox = me.bbox,
+            endLabelStyle = Ext.apply(config, me.seriesLabelStyle);
+
+        return me.chart.surface.add(Ext.apply({
+            'type': 'text',
+            'text-anchor': 'middle',
+            'group': group,
+            'x': item.point[0],
+            'y': bbox.y + bbox.height / 2
+        }, endLabelStyle || {}));
+    },
+
+    
+    onPlaceLabel: function(label, storeItem, item, i, display, animate, index) {
+        var me = this,
+            chart = me.chart,
+            resizing = chart.resizing,
+            config = me.label,
+            format = config.renderer,
+            field = config.field,
+            bbox = me.bbox,
+            x = item.point[0],
+            y = item.point[1],
+            bb, width, height;
+
+        label.setAttributes({
+            text: format(storeItem.get(field[index])),
+            hidden: true
+        }, true);
+
+        bb = label.getBBox();
+        width = bb.width / 2;
+        height = bb.height / 2;
+
+        x = x - width < bbox.x? bbox.x + width : x;
+        x = (x + width > bbox.x + bbox.width) ? (x - (x + width - bbox.x - bbox.width)) : x;
+        y = y - height < bbox.y? bbox.y + height : y;
+        y = (y + height > bbox.y + bbox.height) ? (y - (y + height - bbox.y - bbox.height)) : y;
+
+        if (me.chart.animate && !me.chart.resizing) {
+            label.show(true);
+            me.onAnimate(label, {
+                to: {
+                    x: x,
+                    y: y
+                }
+            });
+        } else {
+            label.setAttributes({
+                x: x,
+                y: y
+            }, true);
+            if (resizing) {
+                me.animation.on('afteranimate', function() {
+                    label.show(true);
+                });
+            } else {
+                label.show(true);
+            }
+        }
+    },
+
+    
+    onPlaceCallout : function(callout, storeItem, item, i, display, animate, index) {
+        var me = this,
+            chart = me.chart,
+            surface = chart.surface,
+            resizing = chart.resizing,
+            config = me.callouts,
+            items = me.items,
+            prev = (i == 0) ? false : items[i -1].point,
+            next = (i == items.length -1) ? false : items[i +1].point,
+            cur = item.point,
+            dir, norm, normal, a, aprev, anext,
+            bbox = callout.label.getBBox(),
+            offsetFromViz = 30,
+            offsetToSide = 10,
+            offsetBox = 3,
+            boxx, boxy, boxw, boxh,
+            p, clipRect = me.clipRect,
+            x, y;
+
+        
+        if (!prev) {
+            prev = cur;
+        }
+        if (!next) {
+            next = cur;
+        }
+        a = (next[1] - prev[1]) / (next[0] - prev[0]);
+        aprev = (cur[1] - prev[1]) / (cur[0] - prev[0]);
+        anext = (next[1] - cur[1]) / (next[0] - cur[0]);
+
+        norm = Math.sqrt(1 + a * a);
+        dir = [1 / norm, a / norm];
+        normal = [-dir[1], dir[0]];
+
+        
+        if (aprev > 0 && anext < 0 && normal[1] < 0 || aprev < 0 && anext > 0 && normal[1] > 0) {
+            normal[0] *= -1;
+            normal[1] *= -1;
+        } else if (Math.abs(aprev) < Math.abs(anext) && normal[0] < 0 || Math.abs(aprev) > Math.abs(anext) && normal[0] > 0) {
+            normal[0] *= -1;
+            normal[1] *= -1;
+        }
+
+        
+        x = cur[0] + normal[0] * offsetFromViz;
+        y = cur[1] + normal[1] * offsetFromViz;
+
+        
+        boxx = x + (normal[0] > 0? 0 : -(bbox.width + 2 * offsetBox));
+        boxy = y - bbox.height /2 - offsetBox;
+        boxw = bbox.width + 2 * offsetBox;
+        boxh = bbox.height + 2 * offsetBox;
+
+        
+        
+        if (boxx < clipRect[0] || (boxx + boxw) > (clipRect[0] + clipRect[2])) {
+            normal[0] *= -1;
+        }
+        if (boxy < clipRect[1] || (boxy + boxh) > (clipRect[1] + clipRect[3])) {
+            normal[1] *= -1;
+        }
+
+        
+        x = cur[0] + normal[0] * offsetFromViz;
+        y = cur[1] + normal[1] * offsetFromViz;
+
+        
+        boxx = x + (normal[0] > 0? 0 : -(bbox.width + 2 * offsetBox));
+        boxy = y - bbox.height /2 - offsetBox;
+        boxw = bbox.width + 2 * offsetBox;
+        boxh = bbox.height + 2 * offsetBox;
+
+        
+        callout.lines.setAttributes({
+            path: ["M", cur[0], cur[1], "L", x, y, "Z"]
+        }, true);
+        
+        callout.box.setAttributes({
+            x: boxx,
+            y: boxy,
+            width: boxw,
+            height: boxh
+        }, true);
+        
+        callout.label.setAttributes({
+            x: x + (normal[0] > 0? offsetBox : -(bbox.width + offsetBox)),
+            y: y
+        }, true);
+        for (p in callout) {
+            callout[p].show(true);
+        }
+    },
+
+    isItemInPoint: function(x, y, item, i) {
+        var me = this,
+            pointsUp = item.pointsUp,
+            pointsDown = item.pointsDown,
+            abs = Math.abs,
+            distChanged = false,
+            last = false,
+            dist = Infinity, p, pln, point;
+
+        for (p = 0, pln = pointsUp.length; p < pln; p++) {
+            point = [pointsUp[p][0], pointsUp[p][1]];
+            
+            distChanged = false;
+            last = p == pln -1;
+
+            if (dist > abs(x - point[0])) {
+                dist = abs(x - point[0]);
+                distChanged = true;
+                if (last) {
+                    ++p;
+                }
+            }
+            
+            if (!distChanged || (distChanged && last)) {
+                point = pointsUp[p -1];
+                if (y >= point[1] && (!pointsDown.length || y <= (pointsDown[p -1][1]))) {
+                    item.storeIndex = p -1;
+                    item.storeField = me.yField[i];
+                    item.storeItem = me.chart.store.getAt(p -1);
+                    item._points = pointsDown.length? [point, pointsDown[p -1]] : [point];
+                    return true;
+                } else {
+                    break;
+                }
+            }
+        }
+        return false;
+    },
+
+    
+    highlightSeries: function() {
+        var area, to, fillColor;
+        if (this._index !== undefined) {
+            area = this.areas[this._index];
+            if (area.__highlightAnim) {
+                area.__highlightAnim.paused = true;
+            }
+            area.__highlighted = true;
+            area.__prevOpacity = area.__prevOpacity || area.attr.opacity || 1;
+            area.__prevFill = area.__prevFill || area.attr.fill;
+            area.__prevLineWidth = area.__prevLineWidth || area.attr.lineWidth;
+            fillColor = Ext.draw.Color.fromString(area.__prevFill);
+            to = {
+                lineWidth: (area.__prevLineWidth || 0) + 2
+            };
+            if (fillColor) {
+                to.fill = fillColor.getLighter(0.2).toString();
+            }
+            else {
+                to.opacity = Math.max(area.__prevOpacity - 0.3, 0);
+            }
+            if (this.chart.animate) {
+                area.__highlightAnim = new Ext.fx.Anim(Ext.apply({
+                    target: area,
+                    to: to
+                }, this.chart.animate));
+            }
+            else {
+                area.setAttributes(to, true);
+            }
+        }
+    },
+
+    
+    unHighlightSeries: function() {
+        var area;
+        if (this._index !== undefined) {
+            area = this.areas[this._index];
+            if (area.__highlightAnim) {
+                area.__highlightAnim.paused = true;
+            }
+            if (area.__highlighted) {
+                area.__highlighted = false;
+                area.__highlightAnim = new Ext.fx.Anim({
+                    target: area,
+                    to: {
+                        fill: area.__prevFill,
+                        opacity: area.__prevOpacity,
+                        lineWidth: area.__prevLineWidth
+                    }
+                });
+            }
+        }
+    },
+
+    
+    highlightItem: function(item) {
+        var me = this,
+            points, path;
+        if (!item) {
+            this.highlightSeries();
+            return;
+        }
+        points = item._points;
+        path = points.length == 2? ['M', points[0][0], points[0][1], 'L', points[1][0], points[1][1]]
+                : ['M', points[0][0], points[0][1], 'L', points[0][0], me.bbox.y + me.bbox.height];
+        me.highlightSprite.setAttributes({
+            path: path,
+            hidden: false
+        }, true);
+    },
+
+    
+    unHighlightItem: function(item) {
+        if (!item) {
+            this.unHighlightSeries();
+        }
+
+        if (this.highlightSprite) {
+            this.highlightSprite.hide(true);
+        }
+    },
+
+    
+    hideAll: function(index) {
+        var me = this;
+        index = (isNaN(me._index) ? index : me._index) || 0;
+        me.__excludes[index] = true;
+        me.areas[index].hide(true);
+        me.redraw();
+    },
+
+    
+    showAll: function(index) {
+        var me = this;
+        index = (isNaN(me._index) ? index : me._index) || 0;
+        me.__excludes[index] = false;
+        me.areas[index].show(true);
+        me.redraw();
+    },
+
+    redraw: function() {
+        
+        
+        
+        var me = this,
+            prevLegendConfig;
+        prevLegendConfig = me.chart.legend.rebuild;
+        me.chart.legend.rebuild = false;
+        me.chart.redraw();
+        me.chart.legend.rebuild = prevLegendConfig;
+    },
+    
+    hide: function() {
+        if (this.areas) {
+            var me = this,
+                areas = me.areas,
+                i, j, l, ln, shadows;
+            
+            if (areas && areas.length) {
+                for (i = 0, ln = areas.length; i < ln; ++i) {
+                    if (areas[i]) {
+                        areas[i].hide(true);
+                    }
+                }
+                me.hideLabels();
+            }
+        }
+    },
+
+    
+    getLegendColor: function(index) {
+        var me = this;
+        return me.colorArrayStyle[index % me.colorArrayStyle.length];
+    }
+});
+
+
+Ext.define('Ext.chart.series.Bar', {
+
+    
+
+    extend: 'Ext.chart.series.Cartesian',
+
+    alternateClassName: ['Ext.chart.BarSeries', 'Ext.chart.BarChart', 'Ext.chart.StackedBarChart'],
+
+    requires: ['Ext.chart.axis.Axis', 'Ext.fx.Anim'],
+
+    
+
+    type: 'bar',
+
+    alias: 'series.bar',
+    
+    column: false,
+
+    
+    style: {},
+
+    
+    gutter: 38.2,
+
+    
+    groupGutter: 38.2,
+
+    
+    xPadding: 0,
+
+    
+    yPadding: 10,
+
+    constructor: function(config) {
+        this.callParent(arguments);
+        var me = this,
+            surface = me.chart.surface,
+            shadow = me.chart.shadow,
+            i, l;
+        config.highlightCfg = Ext.Object.merge({
+            lineWidth: 3,
+            stroke: '#55c',
+            opacity: 0.8,
+            color: '#f00'
+        }, config.highlightCfg);
+        Ext.apply(me, config, {
+            shadowAttributes: [{
+                "stroke-width": 6,
+                "stroke-opacity": 0.05,
+                stroke: 'rgb(200, 200, 200)',
+                translate: {
+                    x: 1.2,
+                    y: 1.2
+                }
+            }, {
+                "stroke-width": 4,
+                "stroke-opacity": 0.1,
+                stroke: 'rgb(150, 150, 150)',
+                translate: {
+                    x: 0.9,
+                    y: 0.9
+                }
+            }, {
+                "stroke-width": 2,
+                "stroke-opacity": 0.15,
+                stroke: 'rgb(100, 100, 100)',
+                translate: {
+                    x: 0.6,
+                    y: 0.6
+                }
+            }]
+        });
+
+        me.group = surface.getGroup(me.seriesId + '-bars');
+        if (shadow) {
+            for (i = 0, l = me.shadowAttributes.length; i < l; i++) {
+                me.shadowGroups.push(surface.getGroup(me.seriesId + '-shadows' + i));
+            }
+        }
+    },
+
+    
+    getBarGirth: function() {
+        var me = this,
+            store = me.chart.getChartStore(),
+            column = me.column,
+            ln = store.getCount(),
+            gutter = me.gutter / 100;
+
+        return (me.chart.chartBBox[column ? 'width' : 'height'] - me[column ? 'xPadding' : 'yPadding'] * 2) / (ln * (gutter + 1) - gutter);
+    },
+
+    
+    getGutters: function() {
+        var me = this,
+            column = me.column,
+            gutter = Math.ceil(me[column ? 'xPadding' : 'yPadding'] + me.getBarGirth() / 2);
+        return me.column ? [gutter, 0] : [0, gutter];
+    },
+
+    
+    getBounds: function() {
+        var me = this,
+            chart = me.chart,
+            store = chart.getChartStore(),
+            data = store.data.items,
+            i, ln, record,
+            bars = [].concat(me.yField),
+            barsLen = bars.length,
+            groupBarsLen = barsLen,
+            groupGutter = me.groupGutter / 100,
+            column = me.column,
+            xPadding = me.xPadding,
+            yPadding = me.yPadding,
+            stacked = me.stacked,
+            barWidth = me.getBarGirth(),
+            barWidthProperty = column ? 'width' : 'height',
+            math = Math,
+            mmin = math.min,
+            mmax = math.max,
+            mabs = math.abs,
+            boundAxes = me.getAxesForXAndYFields(),
+            boundYAxis = boundAxes.yAxis,
+            ends, shrunkBarWidth, groupBarWidth, bbox, minY, maxY, axis, out,
+            scale, zero, total, rec, j, plus, minus;
+
+        me.setBBox(true);
+        bbox = me.bbox;
+
+        
+        if (me.__excludes) {
+            for (j = 0, total = me.__excludes.length; j < total; j++) {
+                if (me.__excludes[j]) {
+                    groupBarsLen--;
+                }
+            }
+        }
+        axis = chart.axes.get(boundYAxis);
+        if (axis) {
+            ends = axis.applyData();
+            minY = ends.from;
+            maxY = ends.to;
+        }
+
+        if (me.yField && !Ext.isNumber(minY)) {
+            out = me.getMinMaxYValues();
+            minY = out[0];
+            maxY = out[1];
+        }
+
+        if (!Ext.isNumber(minY)) {
+            minY = 0;
+        }
+        if (!Ext.isNumber(maxY)) {
+            maxY = 0;
+        }
+        scale = (column ? bbox.height - yPadding * 2 : bbox.width - xPadding * 2) / (maxY - minY);
+        shrunkBarWidth = barWidth;
+        groupBarWidth = (barWidth / ((stacked ? 1 : groupBarsLen) * (groupGutter + 1) - groupGutter));
+        
+        if (barWidthProperty in me.style) {
+            groupBarWidth = mmin(groupBarWidth, me.style[barWidthProperty]);
+            shrunkBarWidth = groupBarWidth * ((stacked ? 1 : groupBarsLen) * (groupGutter + 1) - groupGutter);
+        }
+        zero = (column) ? bbox.y + bbox.height - yPadding : bbox.x + xPadding;
+
+        if (stacked) {
+            total = [[], []];
+            for (i = 0, ln = data.length; i < ln; i++) {
+                record = data[i];
+                total[0][i] = total[0][i] || 0;
+                total[1][i] = total[1][i] || 0;
+                for (j = 0; j < barsLen; j++) {
+                    if (me.__excludes && me.__excludes[j]) {
+                        continue;
+                    }
+                    rec = record.get(bars[j]);
+                    total[+(rec > 0)][i] += mabs(rec);
+                }
+            }
+            total[+(maxY > 0)].push(mabs(maxY));
+            total[+(minY > 0)].push(mabs(minY));
+            minus = mmax.apply(math, total[0]);
+            plus = mmax.apply(math, total[1]);
+            scale = (column ? bbox.height - yPadding * 2 : bbox.width - xPadding * 2) / (plus + minus);
+            zero = zero + minus * scale * (column ? -1 : 1);
+        }
+        else if (minY / maxY < 0) {
+            zero = zero - minY * scale * (column ? -1 : 1);
+        }
+        return {
+            bars: bars,
+            bbox: bbox,
+            shrunkBarWidth: shrunkBarWidth,
+            barsLen: barsLen,
+            groupBarsLen: groupBarsLen,
+            barWidth: barWidth,
+            groupBarWidth: groupBarWidth,
+            scale: scale,
+            zero: zero,
+            xPadding: xPadding,
+            yPadding: yPadding,
+            signed: minY / maxY < 0,
+            minY: minY,
+            maxY: maxY
+        };
+    },
+
+    
+    getPaths: function() {
+        var me = this,
+            chart = me.chart,
+            store = chart.getChartStore(),
+            data = store.data.items,
+            i, total, record,
+            bounds = me.bounds = me.getBounds(),
+            items = me.items = [],
+            yFields = me.yField,
+            gutter = me.gutter / 100,
+            groupGutter = me.groupGutter / 100,
+            animate = chart.animate,
+            column = me.column,
+            group = me.group,
+            enableShadows = chart.shadow,
+            shadowGroups = me.shadowGroups,
+            shadowAttributes = me.shadowAttributes,
+            shadowGroupsLn = shadowGroups.length,
+            bbox = bounds.bbox,
+            barWidth = bounds.barWidth,
+            shrunkBarWidth = bounds.shrunkBarWidth,
+            xPadding = me.xPadding,
+            yPadding = me.yPadding,
+            stacked = me.stacked,
+            barsLen = bounds.barsLen,
+            colors = me.colorArrayStyle,
+            colorLength = colors && colors.length || 0,
+            math = Math,
+            mmax = math.max,
+            mmin = math.min,
+            mabs = math.abs,
+            j, yValue, height, totalDim, totalNegDim, bottom, top, hasShadow, barAttr, attrs, counter,
+            shadowIndex, shadow, sprite, offset, floorY;
+
+        for (i = 0, total = data.length; i < total; i++) {
+            record = data[i];
+            bottom = bounds.zero;
+            top = bounds.zero;
+            totalDim = 0;
+            totalNegDim = 0;
+            hasShadow = false;
+            for (j = 0, counter = 0; j < barsLen; j++) {
+                
+                if (me.__excludes && me.__excludes[j]) {
+                    continue;
+                }
+                yValue = record.get(bounds.bars[j]);
+                height = Math.round((yValue - mmax(bounds.minY, 0)) * bounds.scale);
+                barAttr = {
+                    fill: colors[(barsLen > 1 ? j : 0) % colorLength]
+                };
+                if (column) {
+                    Ext.apply(barAttr, {
+                        height: height,
+                        width: mmax(bounds.groupBarWidth, 0),
+                        x: (bbox.x + xPadding + (barWidth - shrunkBarWidth) * 0.5 + i * barWidth * (1 + gutter) + counter * bounds.groupBarWidth * (1 + groupGutter) * !stacked),
+                        y: bottom - height
+                    });
+                }
+                else {
+                    
+                    offset = (total - 1) - i;
+                    Ext.apply(barAttr, {
+                        height: mmax(bounds.groupBarWidth, 0),
+                        width: height + (bottom == bounds.zero),
+                        x: bottom + (bottom != bounds.zero),
+                        y: (bbox.y + yPadding + (barWidth - shrunkBarWidth) * 0.5 + offset * barWidth * (1 + gutter) + counter * bounds.groupBarWidth * (1 + groupGutter) * !stacked + 1)
+                    });
+                }
+                if (height < 0) {
+                    if (column) {
+                        barAttr.y = top;
+                        barAttr.height = mabs(height);
+                    } else {
+                        barAttr.x = top + height;
+                        barAttr.width = mabs(height);
+                    }
+                }
+                if (stacked) {
+                    if (height < 0) {
+                        top += height * (column ? -1 : 1);
+                    } else {
+                        bottom += height * (column ? -1 : 1);
+                    }
+                    totalDim += mabs(height);
+                    if (height < 0) {
+                        totalNegDim += mabs(height);
+                    }
+                }
+                barAttr.x = Math.floor(barAttr.x) + 1;
+                floorY = Math.floor(barAttr.y);
+                if (!Ext.isIE9 && barAttr.y > floorY) {
+                    floorY--;
+                }
+                barAttr.y = floorY;
+                barAttr.width = Math.floor(barAttr.width);
+                barAttr.height = Math.floor(barAttr.height);
+                items.push({
+                    series: me,
+                    yField: yFields[j],
+                    storeItem: record,
+                    value: [record.get(me.xField), yValue],
+                    attr: barAttr,
+                    point: column ? [barAttr.x + barAttr.width / 2, yValue >= 0 ? barAttr.y : barAttr.y + barAttr.height] :
+                                    [yValue >= 0 ? barAttr.x + barAttr.width : barAttr.x, barAttr.y + barAttr.height / 2]
+                });
+                
+                if (animate && chart.resizing) {
+                    attrs = column ? {
+                        x: barAttr.x,
+                        y: bounds.zero,
+                        width: barAttr.width,
+                        height: 0
+                    } : {
+                        x: bounds.zero,
+                        y: barAttr.y,
+                        width: 0,
+                        height: barAttr.height
+                    };
+                    if (enableShadows && (stacked && !hasShadow || !stacked)) {
+                        hasShadow = true;
+                        
+                        for (shadowIndex = 0; shadowIndex < shadowGroupsLn; shadowIndex++) {
+                            shadow = shadowGroups[shadowIndex].getAt(stacked ? i : (i * barsLen + j));
+                            if (shadow) {
+                                shadow.setAttributes(attrs, true);
+                            }
+                        }
+                    }
+                    
+                    sprite = group.getAt(i * barsLen + j);
+                    if (sprite) {
+                        sprite.setAttributes(attrs, true);
+                    }
+                }
+                counter++;
+            }
+            if (stacked && items.length) {
+                items[i * counter].totalDim = totalDim;
+                items[i * counter].totalNegDim = totalNegDim;
+            }
+        }
+        if (stacked && counter == 0) {
+            
+            for (i = 0, total = data.length; i < total; i++) {
+                for (shadowIndex = 0; shadowIndex < shadowGroupsLn; shadowIndex++) {
+                    shadow = shadowGroups[shadowIndex].getAt(i);
+                    if (shadow) {
+                        shadow.hide(true);
+                    }
+                }
+            }
+        }
+    },
+
+    
+    renderShadows: function(i, barAttr, baseAttrs, bounds) {
+        var me = this,
+            chart = me.chart,
+            surface = chart.surface,
+            animate = chart.animate,
+            stacked = me.stacked,
+            shadowGroups = me.shadowGroups,
+            shadowAttributes = me.shadowAttributes,
+            shadowGroupsLn = shadowGroups.length,
+            store = chart.getChartStore(),
+            column = me.column,
+            items = me.items,
+            shadows = [],
+            zero = bounds.zero,
+            shadowIndex, shadowBarAttr, shadow, totalDim, totalNegDim, j, rendererAttributes;
+
+        if ((stacked && (i % bounds.groupBarsLen === 0)) || !stacked) {
+            j = i / bounds.groupBarsLen;
+            
+            for (shadowIndex = 0; shadowIndex < shadowGroupsLn; shadowIndex++) {
+                shadowBarAttr = Ext.apply({}, shadowAttributes[shadowIndex]);
+                shadow = shadowGroups[shadowIndex].getAt(stacked ? j : i);
+                Ext.copyTo(shadowBarAttr, barAttr, 'x,y,width,height');
+                if (!shadow) {
+                    shadow = surface.add(Ext.apply({
+                        type: 'rect',
+                        group: shadowGroups[shadowIndex]
+                    }, Ext.apply({}, baseAttrs, shadowBarAttr)));
+                }
+                if (stacked) {
+                    totalDim = items[i].totalDim;
+                    totalNegDim = items[i].totalNegDim;
+                    if (column) {
+                        shadowBarAttr.y = zero + totalNegDim - totalDim - 1;
+                        shadowBarAttr.height = totalDim;
+                    }
+                    else {
+                        shadowBarAttr.x = zero - totalNegDim;
+                        shadowBarAttr.width = totalDim;
+                    }
+                }
+                
+                rendererAttributes = me.renderer(shadow, store.getAt(j), shadowBarAttr, i, store);
+                rendererAttributes.hidden = !!barAttr.hidden;
+                if (animate) {
+                    me.onAnimate(shadow, { to: rendererAttributes });
+                }
+                else {
+                    shadow.setAttributes(rendererAttributes, true);
+                }
+                shadows.push(shadow);
+            }
+        }
+        return shadows;
+    },
+
+    
+    drawSeries: function() {
+        var me = this,
+            chart = me.chart,
+            store = chart.getChartStore(),
+            surface = chart.surface,
+            animate = chart.animate,
+            stacked = me.stacked,
+            column = me.column,
+            enableShadows = chart.shadow,
+            shadowGroups = me.shadowGroups,
+            shadowGroupsLn = shadowGroups.length,
+            group = me.group,
+            seriesStyle = me.seriesStyle,
+            items, ln, i, j, baseAttrs, sprite, rendererAttributes, shadowIndex, shadowGroup,
+            bounds, endSeriesStyle, barAttr, attrs, anim;
+
+        if (!store || !store.getCount() || me.seriesIsHidden) {
+            me.hide();
+            me.items = [];
+            return;
+        }
+
+        
+        endSeriesStyle = Ext.apply({}, this.style, seriesStyle);
+        delete endSeriesStyle.fill;
+        delete endSeriesStyle.x;
+        delete endSeriesStyle.y;
+        delete endSeriesStyle.width;
+        delete endSeriesStyle.height;
+        
+        me.unHighlightItem();
+        me.cleanHighlights();
+        
+        me.getPaths();
+        bounds = me.bounds;
+        items = me.items;
+
+        baseAttrs = column ? {
+            y: bounds.zero,
+            height: 0
+        } : {
+            x: bounds.zero,
+            width: 0
+        };
+        ln = items.length;
+        
+        for (i = 0; i < ln; i++) {
+            sprite = group.getAt(i);
+            barAttr = items[i].attr;
+
+            if (enableShadows) {
+                items[i].shadows = me.renderShadows(i, barAttr, baseAttrs, bounds);
+            }
+
+            
+            if (!sprite) {
+                attrs = Ext.apply({}, baseAttrs, barAttr);
+                attrs = Ext.apply(attrs, endSeriesStyle || {});
+                sprite = surface.add(Ext.apply({}, {
+                    type: 'rect',
+                    group: group
+                }, attrs));
+            }
+            if (animate) {
+                rendererAttributes = me.renderer(sprite, store.getAt(i), barAttr, i, store);
+                sprite._to = rendererAttributes;
+                anim = me.onAnimate(sprite, { to: Ext.apply(rendererAttributes, endSeriesStyle) });
+                if (enableShadows && stacked && (i % bounds.barsLen === 0)) {
+                    j = i / bounds.barsLen;
+                    for (shadowIndex = 0; shadowIndex < shadowGroupsLn; shadowIndex++) {
+                        anim.on('afteranimate', function() {
+                            this.show(true);
+                        }, shadowGroups[shadowIndex].getAt(j));
+                    }
+                }
+            }
+            else {
+                rendererAttributes = me.renderer(sprite, store.getAt(i), Ext.apply(barAttr, { hidden: false }), i, store);
+                sprite.setAttributes(Ext.apply(rendererAttributes, endSeriesStyle), true);
+            }
+            items[i].sprite = sprite;
+        }
+
+        
+        ln = group.getCount();
+        for (j = i; j < ln; j++) {
+            group.getAt(j).hide(true);
+        }
+        
+        if (me.stacked) {
+            
+            i = store.getCount();    
+        }
+        
+        
+        if (enableShadows) {
+            for (shadowIndex = 0; shadowIndex < shadowGroupsLn; shadowIndex++) {
+                shadowGroup = shadowGroups[shadowIndex];
+                ln = shadowGroup.getCount();
+                for (j = i; j < ln; j++) {
+                    shadowGroup.getAt(j).hide(true);
+                }
+            }
+        }
+        me.renderLabels();
+    },
+
+    
+    onCreateLabel: function(storeItem, item, i, display) {
+        var me = this,
+            surface = me.chart.surface,
+            group = me.labelsGroup,
+            config = me.label,
+            endLabelStyle = Ext.apply({}, config, me.seriesLabelStyle || {}),
+            sprite;
+        return surface.add(Ext.apply({
+            type: 'text',
+            group: group
+        }, endLabelStyle || {}));
+    },
+
+    
+    onPlaceLabel: function(label, storeItem, item, i, display, animate, j, index) {
+        
+        
+        var me = this,
+            opt = me.bounds,
+            groupBarWidth = opt.groupBarWidth,
+            column = me.column,
+            chart = me.chart,
+            chartBBox = chart.chartBBox,
+            resizing = chart.resizing,
+            xValue = item.value[0],
+            yValue = item.value[1],
+            attr = item.attr,
+            config = me.label,
+            rotate = config.orientation == 'vertical',
+            field = [].concat(config.field),
+            format = config.renderer,
+            text = format(storeItem.get(field[index])),
+            size = me.getLabelSize(text),
+            width = size.width,
+            height = size.height,
+            zero = opt.zero,
+            outside = 'outside',
+            insideStart = 'insideStart',
+            insideEnd = 'insideEnd',
+            offsetX = 10,
+            offsetY = 6,
+            signed = opt.signed,
+            x, y, finalAttr;
+
+        label.setAttributes({
+            text: text
+        });
+
+        label.isOutside = false;
+        if (column) {
+            if (display == outside) {
+                if (height + offsetY + attr.height > (yValue >= 0 ? zero - chartBBox.y : chartBBox.y + chartBBox.height - zero)) {
+                    display = insideEnd;
+                }
+            } else {
+                if (height + offsetY > attr.height) {
+                    display = outside;
+                    label.isOutside = true;
+                }
+            }
+            x = attr.x + groupBarWidth / 2;
+            y = display == insideStart ?
+                    (zero + ((height / 2 + 3) * (yValue >= 0 ? -1 : 1))) :
+                    (yValue >= 0 ? (attr.y + ((height / 2 + 3) * (display == outside ? -1 : 1))) :
+                                   (attr.y + attr.height + ((height / 2 + 3) * (display === outside ? 1 : -1))));
+        }
+        else {
+            if (display == outside) {
+                if (width + offsetX + attr.width > (yValue >= 0 ? chartBBox.x + chartBBox.width - zero : zero - chartBBox.x)) {
+                    display = insideEnd;
+                }
+            }
+            else {
+                if (width + offsetX > attr.width) {
+                    display = outside;
+                    label.isOutside = true;
+                }
+            }
+            x = display == insideStart ?
+                (zero + ((width / 2 + 5) * (yValue >= 0 ? 1 : -1))) :
+                (yValue >= 0 ? (attr.x + attr.width + ((width / 2 + 5) * (display === outside ? 1 : -1))) :
+                (attr.x + ((width / 2 + 5) * (display === outside ? -1 : 1))));
+            y = attr.y + groupBarWidth / 2;
+        }
+        
+        finalAttr = {
+            x: x,
+            y: y
+        };
+        
+        if (rotate) {
+            finalAttr.rotate = {
+                x: x,
+                y: y,
+                degrees: 270
+            };
+        }
+        
+        if (animate && resizing) {
+            if (column) {
+                x = attr.x + attr.width / 2;
+                y = zero;
+            } else {
+                x = zero;
+                y = attr.y + attr.height / 2;
+            }
+            label.setAttributes({
+                x: x,
+                y: y
+            }, true);
+            if (rotate) {
+                label.setAttributes({
+                    rotate: {
+                        x: x,
+                        y: y,
+                        degrees: 270
+                    }
+                }, true);
+            }
+        }
+        
+        if (animate) {
+            me.onAnimate(label, { to: finalAttr });
+        }
+        else {
+            label.setAttributes(Ext.apply(finalAttr, {
+                hidden: false
+            }), true);
+        }
+    },
+
+    
+    getLabelSize: function(value) {
+        var tester = this.testerLabel,
+            config = this.label,
+            endLabelStyle = Ext.apply({}, config, this.seriesLabelStyle || {}),
+            rotated = config.orientation === 'vertical',
+            bbox, w, h,
+            undef;
+        if (!tester) {
+            tester = this.testerLabel = this.chart.surface.add(Ext.apply({
+                type: 'text',
+                opacity: 0
+            }, endLabelStyle));
+        }
+        tester.setAttributes({
+            text: value
+        }, true);
+
+        
+        bbox = tester.getBBox();
+        w = bbox.width;
+        h = bbox.height;
+        return {
+            width: rotated ? h : w,
+            height: rotated ? w : h
+        };
+    },
+
+    
+    onAnimate: function(sprite, attr) {
+        sprite.show();
+        return this.callParent(arguments);
+    },
+
+    isItemInPoint: function(x, y, item) {
+        var bbox = item.sprite.getBBox();
+        return bbox.x <= x && bbox.y <= y
+            && (bbox.x + bbox.width) >= x
+            && (bbox.y + bbox.height) >= y;
+    },
+
+    
+    hideAll: function(index) {
+        var axes      = this.chart.axes,
+            axesItems = axes.items,
+            ln        = axesItems.length,
+            i         = 0;
+
+        index = (isNaN(this._index) ? index : this._index) || 0;
+
+        if (!this.__excludes) {
+            this.__excludes = [];
+        }
+
+        this.__excludes[index] = true;
+        this.drawSeries();
+
+        for (i; i < ln; i++) {
+            axesItems[i].drawAxis();
+        }    
+    },
+
+    
+    showAll: function(index) {
+        var axes = this.chart.axes,
+            axesItems = axes.items,
+            ln        = axesItems.length,
+            i         = 0;
+
+        index = (isNaN(this._index) ? index : this._index) || 0;
+
+        if (!this.__excludes) {
+            this.__excludes = [];
+        }
+
+        this.__excludes[index] = false;
+        this.drawSeries();
+
+        for (i; i < ln; i++) {
+            axesItems[i].drawAxis();
+        }    
+    },
+
+    
+    getLegendColor: function(index) {
+        var me = this,
+            colorLength = me.colorArrayStyle.length;
+
+        if (me.style && me.style.fill) {
+            return me.style.fill;
+        } else {
+            return me.colorArrayStyle[index % colorLength];
+        }
+    },
+
+    highlightItem: function(item) {
+        this.callParent(arguments);
+        this.renderLabels();
+    },
+
+    unHighlightItem: function() {
+        this.callParent(arguments);
+        this.renderLabels();
+    },
+
+    cleanHighlights: function() {
+        this.callParent(arguments);
+        this.renderLabels();
+    }
+});
+
+
+Ext.define('Ext.chart.series.Column', {
+
+    
+
+    alternateClassName: ['Ext.chart.ColumnSeries', 'Ext.chart.ColumnChart', 'Ext.chart.StackedColumnChart'],
+
+    extend: 'Ext.chart.series.Bar',
+
+    
+
+    type: 'column',
+    alias: 'series.column',
+
+    column: true,
+
+    
+    xPadding: 10,
+
+    
+    yPadding: 0
+});
+
+
+Ext.define('Ext.chart.series.Gauge', {
+
+    
+
+    extend: 'Ext.chart.series.Series',
+
+    
+
+    type: "gauge",
+    alias: 'series.gauge',
+
+    rad: Math.PI / 180,
+
+    
+    highlightDuration: 150,
+
+    
+    angleField: false,
+
+    
+    needle: false,
+    
+    
+    donut: false,
+
+    
+    showInLegend: false,
+
+    
+    style: {},
+    
+    constructor: function(config) {
+        this.callParent(arguments);
+        var me = this,
+            chart = me.chart,
+            surface = chart.surface,
+            store = chart.store,
+            shadow = chart.shadow, i, l, cfg;
+        Ext.apply(me, config, {
+            shadowAttributes: [{
+                "stroke-width": 6,
+                "stroke-opacity": 1,
+                stroke: 'rgb(200, 200, 200)',
+                translate: {
+                    x: 1.2,
+                    y: 2
+                }
+            },
+            {
+                "stroke-width": 4,
+                "stroke-opacity": 1,
+                stroke: 'rgb(150, 150, 150)',
+                translate: {
+                    x: 0.9,
+                    y: 1.5
+                }
+            },
+            {
+                "stroke-width": 2,
+                "stroke-opacity": 1,
+                stroke: 'rgb(100, 100, 100)',
+                translate: {
+                    x: 0.6,
+                    y: 1
+                }
+            }]
+        });
+        me.group = surface.getGroup(me.seriesId);
+        if (shadow) {
+            for (i = 0, l = me.shadowAttributes.length; i < l; i++) {
+                me.shadowGroups.push(surface.getGroup(me.seriesId + '-shadows' + i));
+            }
+        }
+        surface.customAttributes.segment = function(opt) {
+            return me.getSegment(opt);
+        };
+    },
+    
+    
+    initialize: function() {
+        var me = this,
+            store = me.chart.getChartStore(),
+            data = store.data.items,
+            i, ln, rec;
+        
+        me.yField = [];
+        if (me.label.field) {
+            for (i = 0, ln = data.length; i < ln; i++) {
+                rec = data[i];
+                me.yField.push(rec.get(me.label.field));
+            }
+        }
+    },
+
+    
+    getSegment: function(opt) {
+        var me = this,
+            rad = me.rad,
+            cos = Math.cos,
+            sin = Math.sin,
+            abs = Math.abs,
+            x = me.centerX,
+            y = me.centerY,
+            x1 = 0, x2 = 0, x3 = 0, x4 = 0,
+            y1 = 0, y2 = 0, y3 = 0, y4 = 0,
+            delta = 1e-2,
+            r = opt.endRho - opt.startRho,
+            startAngle = opt.startAngle,
+            endAngle = opt.endAngle,
+            midAngle = (startAngle + endAngle) / 2 * rad,
+            margin = opt.margin || 0,
+            flag = abs(endAngle - startAngle) > 180,
+            a1 = Math.min(startAngle, endAngle) * rad,
+            a2 = Math.max(startAngle, endAngle) * rad,
+            singleSlice = false;
+
+        x += margin * cos(midAngle);
+        y += margin * sin(midAngle);
+
+        x1 = x + opt.startRho * cos(a1);
+        y1 = y + opt.startRho * sin(a1);
+
+        x2 = x + opt.endRho * cos(a1);
+        y2 = y + opt.endRho * sin(a1);
+
+        x3 = x + opt.startRho * cos(a2);
+        y3 = y + opt.startRho * sin(a2);
+
+        x4 = x + opt.endRho * cos(a2);
+        y4 = y + opt.endRho * sin(a2);
+
+        if (abs(x1 - x3) <= delta && abs(y1 - y3) <= delta) {
+            singleSlice = true;
+        }
+        
+        if (singleSlice) {
+            return {
+                path: [
+                ["M", x1, y1],
+                ["L", x2, y2],
+                ["A", opt.endRho, opt.endRho, 0, +flag, 1, x4, y4],
+                ["Z"]]
+            };
+        } else {
+            return {
+                path: [
+                ["M", x1, y1],
+                ["L", x2, y2],
+                ["A", opt.endRho, opt.endRho, 0, +flag, 1, x4, y4],
+                ["L", x3, y3],
+                ["A", opt.startRho, opt.startRho, 0, +flag, 0, x1, y1],
+                ["Z"]]
+            };
+        }
+    },
+
+    
+    calcMiddle: function(item) {
+        var me = this,
+            rad = me.rad,
+            slice = item.slice,
+            x = me.centerX,
+            y = me.centerY,
+            startAngle = slice.startAngle,
+            endAngle = slice.endAngle,
+            radius = Math.max(('rho' in slice) ? slice.rho: me.radius, me.label.minMargin),
+            donut = +me.donut,
+            a1 = Math.min(startAngle, endAngle) * rad,
+            a2 = Math.max(startAngle, endAngle) * rad,
+            midAngle = -(a1 + (a2 - a1) / 2),
+            xm = x + (item.endRho + item.startRho) / 2 * Math.cos(midAngle),
+            ym = y - (item.endRho + item.startRho) / 2 * Math.sin(midAngle);
+
+        item.middle = {
+            x: xm,
+            y: ym
+        };
+    },
+
+    
+    drawSeries: function() {
+        var me = this,
+            chart = me.chart,
+            store = chart.getChartStore(),
+            group = me.group,
+            animate = me.chart.animate,
+            axis = me.chart.axes.get(0),
+            minimum = axis && axis.minimum || me.minimum || 0,
+            maximum = axis && axis.maximum || me.maximum || 0,
+            field = me.angleField || me.field || me.xField,
+            surface = chart.surface,
+            chartBBox = chart.chartBBox,
+            rad = me.rad,
+            donut = +me.donut,
+            values = {},
+            items = [],
+            seriesStyle = me.seriesStyle,
+            seriesLabelStyle = me.seriesLabelStyle,
+            colorArrayStyle = me.colorArrayStyle,
+            colorArrayLength = colorArrayStyle && colorArrayStyle.length || 0,
+            gutterX = chart.maxGutter[0],
+            gutterY = chart.maxGutter[1],
+            cos = Math.cos,
+            sin = Math.sin,
+            rendererAttributes, centerX, centerY, slice, slices, sprite, value,
+            item, ln, record, i, j, startAngle, endAngle, middleAngle, sliceLength, path,
+            p, spriteOptions, bbox, splitAngle, sliceA, sliceB;
+        
+        Ext.apply(seriesStyle, me.style || {});
+
+        me.setBBox();
+        bbox = me.bbox;
+
+        
+        if (me.colorSet) {
+            colorArrayStyle = me.colorSet;
+            colorArrayLength = colorArrayStyle.length;
+        }
+        
+        
+        if (!store || !store.getCount() || me.seriesIsHidden) {
+            me.hide();
+            me.items = [];
+            return;
+        }
+        
+        centerX = me.centerX = chartBBox.x + (chartBBox.width / 2);
+        centerY = me.centerY = chartBBox.y + chartBBox.height;
+        me.radius = Math.min(centerX - chartBBox.x, centerY - chartBBox.y);
+        me.slices = slices = [];
+        me.items = items = [];
+        
+        if (!me.value) {
+            record = store.getAt(0);
+            me.value = record.get(field);
+        }
+        
+        value = me.value;
+        if (me.needle) {
+            sliceA = {
+                series: me,
+                value: value,
+                startAngle: -180,
+                endAngle: 0,
+                rho: me.radius
+            };
+            splitAngle = -180 * (1 - (value - minimum) / (maximum - minimum));
+            slices.push(sliceA);
+        } else {
+            splitAngle = -180 * (1 - (value - minimum) / (maximum - minimum));
+            sliceA = {
+                series: me,
+                value: value,
+                startAngle: -180,
+                endAngle: splitAngle,
+                rho: me.radius
+            };
+            sliceB = {
+                series: me,
+                value: me.maximum - value,
+                startAngle: splitAngle,
+                endAngle: 0,
+                rho: me.radius
+            };
+            slices.push(sliceA, sliceB);
+        }
+        
+        
+        for (i = 0, ln = slices.length; i < ln; i++) {
+            slice = slices[i];
+            sprite = group.getAt(i);
+            
+            rendererAttributes = Ext.apply({
+                segment: {
+                    startAngle: slice.startAngle,
+                    endAngle: slice.endAngle,
+                    margin: 0,
+                    rho: slice.rho,
+                    startRho: slice.rho * +donut / 100,
+                    endRho: slice.rho
+                } 
+            }, Ext.apply(seriesStyle, colorArrayStyle && { fill: colorArrayStyle[i % colorArrayLength] } || {}));
+
+            item = Ext.apply({},
+            rendererAttributes.segment, {
+                slice: slice,
+                series: me,
+                storeItem: record,
+                index: i
+            });
+            items[i] = item;
+            
+            if (!sprite) {
+                spriteOptions = Ext.apply({
+                    type: "path",
+                    group: group
+                }, Ext.apply(seriesStyle, colorArrayStyle && { fill: colorArrayStyle[i % colorArrayLength] } || {}));
+                sprite = surface.add(Ext.apply(spriteOptions, rendererAttributes));
+            }
+            slice.sprite = slice.sprite || [];
+            item.sprite = sprite;
+            slice.sprite.push(sprite);
+            if (animate) {
+                rendererAttributes = me.renderer(sprite, record, rendererAttributes, i, store);
+                sprite._to = rendererAttributes;
+                me.onAnimate(sprite, {
+                    to: rendererAttributes
+                });
+            } else {
+                rendererAttributes = me.renderer(sprite, record, Ext.apply(rendererAttributes, {
+                    hidden: false
+                }), i, store);
+                sprite.setAttributes(rendererAttributes, true);
+            }
+        }
+        
+        if (me.needle) {
+            splitAngle = splitAngle * Math.PI / 180;
+            
+            if (!me.needleSprite) {
+                me.needleSprite = me.chart.surface.add({
+                    type: 'path',
+                    path: ['M', centerX + (me.radius * +donut / 100) * cos(splitAngle),
+                                centerY + -Math.abs((me.radius * +donut / 100) * sin(splitAngle)),
+                           'L', centerX + me.radius * cos(splitAngle),
+                                centerY + -Math.abs(me.radius * sin(splitAngle))],
+                    'stroke-width': 4,
+                    'stroke': '#222'
+                });
+            } else {
+                if (animate) {
+                    me.onAnimate(me.needleSprite, {
+                        to: {
+                        path: ['M', centerX + (me.radius * +donut / 100) * cos(splitAngle),
+                                    centerY + -Math.abs((me.radius * +donut / 100) * sin(splitAngle)),
+                               'L', centerX + me.radius * cos(splitAngle),
+                                    centerY + -Math.abs(me.radius * sin(splitAngle))]
+                        }
+                    });
+                } else {
+                    me.needleSprite.setAttributes({
+                        type: 'path',
+                        path: ['M', centerX + (me.radius * +donut / 100) * cos(splitAngle),
+                                    centerY + -Math.abs((me.radius * +donut / 100) * sin(splitAngle)),
+                               'L', centerX + me.radius * cos(splitAngle),
+                                    centerY + -Math.abs(me.radius * sin(splitAngle))]
+                    });
+                }
+            }
+            me.needleSprite.setAttributes({
+                hidden: false    
+            }, true);
+        }
+        
+        delete me.value;
+    },
+    
+    
+    setValue: function (value) {
+        this.value = value;
+        this.drawSeries();
+    },
+
+    
+    onCreateLabel: function(storeItem, item, i, display) {},
+
+    
+    onPlaceLabel: function(label, storeItem, item, i, display, animate, index) {},
+
+    
+    onPlaceCallout: function() {},
+
+    
+    onAnimate: function(sprite, attr) {
+        sprite.show();
+        return this.callParent(arguments);
+    },
+
+    isItemInPoint: function(x, y, item, i) {
+        var me = this,
+            cx = me.centerX,
+            cy = me.centerY,
+            abs = Math.abs,
+            dx = abs(x - cx),
+            dy = abs(y - cy),
+            startAngle = item.startAngle,
+            endAngle = item.endAngle,
+            rho = Math.sqrt(dx * dx + dy * dy),
+            angle = Math.atan2(y - cy, x - cx) / me.rad;
+
+        
+        return (i === 0) && (angle >= startAngle && angle < endAngle && 
+                             rho >= item.startRho && rho <= item.endRho);
+    },
+    
+    
+    showAll: function() {
+        if (!isNaN(this._index)) {
+            this.__excludes[this._index] = false;
+            this.drawSeries();
+        }
+    },
+    
+    
+    getLegendColor: function(index) {
+        var me = this;
+        return me.colorArrayStyle[index % me.colorArrayStyle.length];
+    }
+});
+
+
+
+Ext.define('Ext.chart.series.Line', {
+
+    
+
+    extend: 'Ext.chart.series.Cartesian',
+
+    alternateClassName: ['Ext.chart.LineSeries', 'Ext.chart.LineChart'],
+
+    requires: ['Ext.chart.axis.Axis', 'Ext.chart.Shape', 'Ext.draw.Draw', 'Ext.fx.Anim'],
+
+    
+
+    type: 'line',
+
+    alias: 'series.line',
+
+    
+
+    
+    selectionTolerance: 20,
+
+    
+    showMarkers: true,
+
+    
+    markerConfig: {},
+
+    
+    style: {},
+
+    
+    smooth: false,
+
+    
+    defaultSmoothness: 3,
+
+    
+    fill: false,
+
+    constructor: function(config) {
+        this.callParent(arguments);
+        var me = this,
+            surface = me.chart.surface,
+            shadow = me.chart.shadow,
+            i, l;
+        config.highlightCfg = Ext.Object.merge({ 'stroke-width': 3 }, config.highlightCfg);
+        Ext.apply(me, config, {
+            shadowAttributes: [{
+                "stroke-width": 6,
+                "stroke-opacity": 0.05,
+                stroke: 'rgb(0, 0, 0)',
+                translate: {
+                    x: 1,
+                    y: 1
+                }
+            }, {
+                "stroke-width": 4,
+                "stroke-opacity": 0.1,
+                stroke: 'rgb(0, 0, 0)',
+                translate: {
+                    x: 1,
+                    y: 1
+                }
+            }, {
+                "stroke-width": 2,
+                "stroke-opacity": 0.15,
+                stroke: 'rgb(0, 0, 0)',
+                translate: {
+                    x: 1,
+                    y: 1
+                }
+            }]
+        });
+        me.group = surface.getGroup(me.seriesId);
+        if (me.showMarkers) {
+            me.markerGroup = surface.getGroup(me.seriesId + '-markers');
+        }
+        if (shadow) {
+            for (i = 0, l = me.shadowAttributes.length; i < l; i++) {
+                me.shadowGroups.push(surface.getGroup(me.seriesId + '-shadows' + i));
+            }
+        }
+    },
+
+    
+    shrink: function(xValues, yValues, size) {
+        
+        var len = xValues.length,
+            ratio = Math.floor(len / size),
+            i = 1,
+            xSum = 0,
+            ySum = 0,
+            xRes = [+xValues[0]],
+            yRes = [+yValues[0]];
+
+        for (; i < len; ++i) {
+            xSum += +xValues[i] || 0;
+            ySum += +yValues[i] || 0;
+            if (i % ratio == 0) {
+                xRes.push(xSum/ratio);
+                yRes.push(ySum/ratio);
+                xSum = 0;
+                ySum = 0;
+            }
+        }
+        return {
+            x: xRes,
+            y: yRes
+        };
+    },
+
+    
+    drawSeries: function() {
+        var me = this,
+            chart = me.chart,
+            chartAxes = chart.axes,
+            store = chart.getChartStore(),
+            data = store.data.items,
+            record,
+            storeCount = store.getCount(),
+            surface = me.chart.surface,
+            bbox = {},
+            group = me.group,
+            showMarkers = me.showMarkers,
+            markerGroup = me.markerGroup,
+            enableShadows = chart.shadow,
+            shadowGroups = me.shadowGroups,
+            shadowAttributes = me.shadowAttributes,
+            smooth = me.smooth,
+            lnsh = shadowGroups.length,
+            dummyPath = ["M"],
+            path = ["M"],
+            renderPath = ["M"],
+            smoothPath = ["M"],
+            markerIndex = chart.markerIndex,
+            axes = [].concat(me.axis),
+            shadowBarAttr,
+            xValues = [],
+            xValueMap = {},
+            yValues = [],
+            yValueMap = {},
+            onbreak = false,
+            storeIndices = [],
+            markerStyle = me.markerStyle,
+            seriesStyle = me.seriesStyle,
+            colorArrayStyle = me.colorArrayStyle,
+            colorArrayLength = colorArrayStyle && colorArrayStyle.length || 0,
+            isNumber = Ext.isNumber,
+            seriesIdx = me.seriesIdx, 
+            boundAxes = me.getAxesForXAndYFields(),
+            boundXAxis = boundAxes.xAxis,
+            boundYAxis = boundAxes.yAxis,
+            shadows, shadow, shindex, fromPath, fill, fillPath, rendererAttributes,
+            x, y, prevX, prevY, firstX, firstY, markerCount, i, j, ln, axis, ends, marker, markerAux, item, xValue,
+            yValue, coords, xScale, yScale, minX, maxX, minY, maxY, line, animation, endMarkerStyle,
+            endLineStyle, type, count, opacity, lineOpacity, fillOpacity, fillDefaultValue;
+
+        if (me.fireEvent('beforedraw', me) === false) {
+            return;
+        }
+
+        
+        if (!storeCount || me.seriesIsHidden) {
+            me.hide();
+            me.items = [];
+            if (me.line) {
+                me.line.hide(true);
+                if (me.line.shadows) {
+                    shadows = me.line.shadows;
+                    for (j = 0, lnsh = shadows.length; j < lnsh; j++) {
+                        shadow = shadows[j];
+                        shadow.hide(true);
+                    }
+                }
+                if (me.fillPath) {
+                    me.fillPath.hide(true);
+                }
+            }
+            me.line = null;
+            me.fillPath = null;
+            return;
+        }
+
+        
+        endMarkerStyle = Ext.apply(markerStyle || {}, me.markerConfig, {
+            fill: me.seriesStyle.fill || colorArrayStyle[seriesIdx % colorArrayStyle.length]
+        });
+        type = endMarkerStyle.type;
+        delete endMarkerStyle.type;
+        endLineStyle = seriesStyle;
+        
+        
+        if (!endLineStyle['stroke-width']) {
+            endLineStyle['stroke-width'] = 0.5;
+        }
+        
+        
+        opacity = 'opacity' in endLineStyle ? endLineStyle.opacity : 1;
+        fillDefaultValue = 'opacity' in endLineStyle ? endLineStyle.opacity : 0.3;
+        lineOpacity = 'lineOpacity' in endLineStyle ? endLineStyle.lineOpacity : opacity;
+        fillOpacity = 'fillOpacity' in endLineStyle ? endLineStyle.fillOpacity : fillDefaultValue;
+
+        
+        
+        if (markerIndex && markerGroup && markerGroup.getCount()) {
+            for (i = 0; i < markerIndex; i++) {
+                marker = markerGroup.getAt(i);
+                markerGroup.remove(marker);
+                markerGroup.add(marker);
+                markerAux = markerGroup.getAt(markerGroup.getCount() - 2);
+                marker.setAttributes({
+                    x: 0,
+                    y: 0,
+                    translate: {
+                        x: markerAux.attr.translation.x,
+                        y: markerAux.attr.translation.y
+                    }
+                }, true);
+            }
+        }
+
+        me.unHighlightItem();
+        me.cleanHighlights();
+
+        me.setBBox();
+        bbox = me.bbox;
+        me.clipRect = [bbox.x, bbox.y, bbox.width, bbox.height];
+
+        if (axis = chartAxes.get(boundXAxis)) {
+            ends = axis.applyData();
+            minX = ends.from;
+            maxX = ends.to;
+        }
+
+        if (axis = chartAxes.get(boundYAxis)) {
+            ends = axis.applyData();
+            minY = ends.from;
+            maxY = ends.to;
+        }
+
+        
+        if (me.xField && !Ext.isNumber(minX)) {
+            axis = me.getMinMaxXValues();
+            minX = axis[0];
+            maxX = axis[1];
+        }
+
+        if (me.yField && !Ext.isNumber(minY)) {
+            axis = me.getMinMaxYValues();
+            minY = axis[0];
+            maxY = axis[1];
+        }
+        
+        if (isNaN(minX)) {
+            minX = 0;
+            xScale = bbox.width / ((storeCount - 1) || 1);
+        }
+        else {
+            xScale = bbox.width / ((maxX - minX) || (storeCount -1) || 1);
+        }
+
+        if (isNaN(minY)) {
+            minY = 0;
+            yScale = bbox.height / ((storeCount - 1) || 1);
+        }
+        else {
+            yScale = bbox.height / ((maxY - minY) || (storeCount - 1) || 1);
+        }
+        
+        for (i = 0, ln = data.length; i < ln; i++) {
+            record = data[i];
+            xValue = record.get(me.xField);
+
+            
+            if (typeof xValue == 'string' || typeof xValue == 'object' && !Ext.isDate(xValue)
+                
+                || boundXAxis && chartAxes.get(boundXAxis) && chartAxes.get(boundXAxis).type == 'Category') {
+                    if (xValue in xValueMap) {
+                        xValue = xValueMap[xValue];
+                    } else {
+                        xValue = xValueMap[xValue] = i;
+                    }
+            }
+
+            
+            yValue = record.get(me.yField);
+            
+            if (typeof yValue == 'undefined' || (typeof yValue == 'string' && !yValue)) {
+                continue;
+            }
+            
+            if (typeof yValue == 'string' || typeof yValue == 'object' && !Ext.isDate(yValue)
+                
+                || boundYAxis && chartAxes.get(boundYAxis) && chartAxes.get(boundYAxis).type == 'Category') {
+                yValue = i;
+            }
+            storeIndices.push(i);
+            xValues.push(xValue);
+            yValues.push(yValue);
+        }
+
+        ln = xValues.length;
+        if (ln > bbox.width) {
+            coords = me.shrink(xValues, yValues, bbox.width);
+            xValues = coords.x;
+            yValues = coords.y;
+        }
+
+        me.items = [];
+
+        count = 0;
+        ln = xValues.length;
+        for (i = 0; i < ln; i++) {
+            xValue = xValues[i];
+            yValue = yValues[i];
+            if (yValue === false) {
+                if (path.length == 1) {
+                    path = [];
+                }
+                onbreak = true;
+                me.items.push(false);
+                continue;
+            } else {
+                x = (bbox.x + (xValue - minX) * xScale).toFixed(2);
+                y = ((bbox.y + bbox.height) - (yValue - minY) * yScale).toFixed(2);
+                if (onbreak) {
+                    onbreak = false;
+                    path.push('M');
+                }
+                path = path.concat([x, y]);
+            }
+            if ((typeof firstY == 'undefined') && (typeof y != 'undefined')) {
+                firstY = y;
+                firstX = x;
+            }
+            
+            if (!me.line || chart.resizing) {
+                dummyPath = dummyPath.concat([x, bbox.y + bbox.height / 2]);
+            }
+
+            
+            if (chart.animate && chart.resizing && me.line) {
+                me.line.setAttributes({
+                    path: dummyPath,
+                    opacity: lineOpacity
+                }, true);
+                if (me.fillPath) {
+                    me.fillPath.setAttributes({
+                        path: dummyPath,
+                        opacity: fillOpacity
+                    }, true);
+                }
+                if (me.line.shadows) {
+                    shadows = me.line.shadows;
+                    for (j = 0, lnsh = shadows.length; j < lnsh; j++) {
+                        shadow = shadows[j];
+                        shadow.setAttributes({
+                            path: dummyPath
+                        }, true);
+                    }
+                }
+            }
+            if (showMarkers) {
+                marker = markerGroup.getAt(count++);
+                if (!marker) {
+                    marker = Ext.chart.Shape[type](surface, Ext.apply({
+                        group: [group, markerGroup],
+                        x: 0, y: 0,
+                        translate: {
+                            x: +(prevX || x),
+                            y: prevY || (bbox.y + bbox.height / 2)
+                        },
+                        value: '"' + xValue + ', ' + yValue + '"',
+                        zIndex: 4000
+                    }, endMarkerStyle));
+                    marker._to = {
+                        translate: {
+                            x: +x,
+                            y: +y
+                        }
+                    };
+                } else {
+                    marker.setAttributes({
+                        value: '"' + xValue + ', ' + yValue + '"',
+                        x: 0, y: 0,
+                        hidden: false
+                    }, true);
+                    marker._to = {
+                        translate: {
+                            x: +x, 
+                            y: +y
+                        }
+                    };
+                }
+            }
+            me.items.push({
+                series: me,
+                value: [xValue, yValue],
+                point: [x, y],
+                sprite: marker,
+                storeItem: store.getAt(storeIndices[i])
+            });
+            prevX = x;
+            prevY = y;
+        }
+
+        if (path.length <= 1) {
+            
+            return;
+        }
+
+        if (me.smooth) {
+            smoothPath = Ext.draw.Draw.smooth(path, isNumber(smooth) ? smooth : me.defaultSmoothness);
+        }
+
+        renderPath = smooth ? smoothPath : path;
+
+        
+        if (chart.markerIndex && me.previousPath) {
+            fromPath = me.previousPath;
+            if (!smooth) {
+                Ext.Array.erase(fromPath, 1, 2);
+            }
+        } else {
+            fromPath = path;
+        }
+
+        
+        if (!me.line) {
+            me.line = surface.add(Ext.apply({
+                type: 'path',
+                group: group,
+                path: dummyPath,
+                stroke: endLineStyle.stroke || endLineStyle.fill
+            }, endLineStyle || {}));
+
+            
+            me.line.setAttributes({
+                opacity: lineOpacity
+            }, true);
+
+            if (enableShadows) {
+                me.line.setAttributes(Ext.apply({}, me.shadowOptions), true);
+            }
+
+            
+            me.line.setAttributes({
+                fill: 'none',
+                zIndex: 3000
+            });
+            if (!endLineStyle.stroke && colorArrayLength) {
+                me.line.setAttributes({
+                    stroke: colorArrayStyle[seriesIdx % colorArrayLength]
+                }, true);
+            }
+            if (enableShadows) {
+                
+                shadows = me.line.shadows = [];
+                for (shindex = 0; shindex < lnsh; shindex++) {
+                    shadowBarAttr = shadowAttributes[shindex];
+                    shadowBarAttr = Ext.apply({}, shadowBarAttr, { path: dummyPath });
+                    shadow = surface.add(Ext.apply({}, {
+                        type: 'path',
+                        group: shadowGroups[shindex]
+                    }, shadowBarAttr));
+                    shadows.push(shadow);
+                }
+            }
+        }
+        if (me.fill) {
+            fillPath = renderPath.concat([
+                ["L", x, bbox.y + bbox.height],
+                ["L", firstX, bbox.y + bbox.height],
+                ["L", firstX, firstY]
+            ]);
+            if (!me.fillPath) {
+                me.fillPath = surface.add({
+                    group: group,
+                    type: 'path',
+                    fill: endLineStyle.fill || colorArrayStyle[seriesIdx % colorArrayLength],
+                    path: dummyPath
+                });
+            }
+        }
+        markerCount = showMarkers && markerGroup.getCount();
+        if (chart.animate) {
+            fill = me.fill;
+            line = me.line;
+            
+            rendererAttributes = me.renderer(line, false, { path: renderPath }, i, store);
+            Ext.apply(rendererAttributes, endLineStyle || {}, {
+                stroke: endLineStyle.stroke || endLineStyle.fill
+            });
+            
+            delete rendererAttributes.fill;
+            line.show(true);
+            if (chart.markerIndex && me.previousPath) {
+                me.animation = animation = me.onAnimate(line, {
+                    to: rendererAttributes,
+                    from: {
+                        path: fromPath
+                    }
+                });
+            } else {
+                me.animation = animation = me.onAnimate(line, {
+                    to: rendererAttributes
+                });
+            }
+            
+            if (enableShadows) {
+                shadows = line.shadows;
+                for(j = 0; j < lnsh; j++) {
+                    shadows[j].show(true);
+                    if (chart.markerIndex && me.previousPath) {
+                        me.onAnimate(shadows[j], {
+                            to: { path: renderPath },
+                            from: { path: fromPath }
+                        });
+                    } else {
+                        me.onAnimate(shadows[j], {
+                            to: { path: renderPath }
+                        });
+                    }
+                }
+            }
+            
+            if (fill) {
+                me.fillPath.show(true);
+                me.onAnimate(me.fillPath, {
+                    to: Ext.apply({}, {
+                        path: fillPath,
+                        fill: endLineStyle.fill || colorArrayStyle[seriesIdx % colorArrayLength],
+                        'stroke-width': 0,
+                        opacity: fillOpacity
+                    }, endLineStyle || {})
+                });
+            }
+            
+            if (showMarkers) {
+                count = 0;
+                for(i = 0; i < ln; i++) {
+                    if (me.items[i]) {
+                        item = markerGroup.getAt(count++);
+                        if (item) {
+                            rendererAttributes = me.renderer(item, store.getAt(i), item._to, i, store);
+                            me.onAnimate(item, {
+                                to: Ext.apply(rendererAttributes, endMarkerStyle || {})
+                            });
+                            item.show(true);
+                        }
+                    }
+                }
+                for(; count < markerCount; count++) {
+                    item = markerGroup.getAt(count);
+                    item.hide(true);
+                }
+
+
+
+
+            }
+        } else {
+            rendererAttributes = me.renderer(me.line, false, { path: renderPath, hidden: false }, i, store);
+            Ext.apply(rendererAttributes, endLineStyle || {}, {
+                stroke: endLineStyle.stroke || endLineStyle.fill
+            });
+            
+            delete rendererAttributes.fill;
+            me.line.setAttributes(rendererAttributes, true);
+            me.line.setAttributes({
+                opacity: lineOpacity
+            }, true);
+            
+            if (enableShadows) {
+                shadows = me.line.shadows;
+                for(j = 0; j < lnsh; j++) {
+                    shadows[j].setAttributes({
+                        path: renderPath,
+                        hidden: false
+                    }, true);
+                }
+            }
+            if (me.fill) {
+                me.fillPath.setAttributes({
+                    path: fillPath,
+                    hidden: false,
+                    opacity: fillOpacity
+                }, true);
+            }
+            if (showMarkers) {
+                count = 0;
+                for(i = 0; i < ln; i++) {
+                    if (me.items[i]) {
+                        item = markerGroup.getAt(count++);
+                        if (item) {
+                            rendererAttributes = me.renderer(item, store.getAt(i), item._to, i, store);
+                            item.setAttributes(Ext.apply(endMarkerStyle || {}, rendererAttributes || {}), true);
+                            if (!item.attr.hidden) {
+                                item.show(true);
+                            }
+                        }
+                    }
+                }
+                for(; count < markerCount; count++) {
+                    item = markerGroup.getAt(count);
+                    item.hide(true);
+                }
+            }
+        }
+
+        if (chart.markerIndex) {
+            if (me.smooth) {
+                Ext.Array.erase(path, 1, 2);
+            } else {
+                Ext.Array.splice(path, 1, 0, path[1], path[2]);
+            }
+            me.previousPath = path;
+        }
+        me.renderLabels();
+        me.renderCallouts();
+
+        me.fireEvent('draw', me);
+    },
+
+    
+    onCreateLabel: function(storeItem, item, i, display) {
+        var me = this,
+            group = me.labelsGroup,
+            config = me.label,
+            bbox = me.bbox,
+            endLabelStyle = Ext.apply(config, me.seriesLabelStyle);
+
+        return me.chart.surface.add(Ext.apply({
+            'type': 'text',
+            'text-anchor': 'middle',
+            'group': group,
+            'x': item.point[0],
+            'y': bbox.y + bbox.height / 2
+        }, endLabelStyle || {}));
+    },
+
+    
+    onPlaceLabel: function(label, storeItem, item, i, display, animate) {
+        var me = this,
+            chart = me.chart,
+            resizing = chart.resizing,
+            config = me.label,
+            format = config.renderer,
+            field = config.field,
+            bbox = me.bbox,
+            x = item.point[0],
+            y = item.point[1],
+            radius = item.sprite.attr.radius,
+            bb, width, height;
+
+        label.setAttributes({
+            text: format(storeItem.get(field)),
+            hidden: true
+        }, true);
+
+        if (display == 'rotate') {
+            label.setAttributes({
+                'text-anchor': 'start',
+                'rotation': {
+                    x: x,
+                    y: y,
+                    degrees: -45
+                }
+            }, true);
+            
+            bb = label.getBBox();
+            width = bb.width;
+            height = bb.height;
+            x = x < bbox.x? bbox.x : x;
+            x = (x + width > bbox.x + bbox.width)? (x - (x + width - bbox.x - bbox.width)) : x;
+            y = (y - height < bbox.y)? bbox.y + height : y;
+
+        } else if (display == 'under' || display == 'over') {
+            
+            bb = item.sprite.getBBox();
+            bb.width = bb.width || (radius * 2);
+            bb.height = bb.height || (radius * 2);
+            y = y + (display == 'over'? -bb.height : bb.height);
+            
+            bb = label.getBBox();
+            width = bb.width/2;
+            height = bb.height/2;
+            x = x - width < bbox.x? bbox.x + width : x;
+            x = (x + width > bbox.x + bbox.width) ? (x - (x + width - bbox.x - bbox.width)) : x;
+            y = y - height < bbox.y? bbox.y + height : y;
+            y = (y + height > bbox.y + bbox.height) ? (y - (y + height - bbox.y - bbox.height)) : y;
+        }
+
+        if (me.chart.animate && !me.chart.resizing) {
+            label.show(true);
+            me.onAnimate(label, {
+                to: {
+                    x: x,
+                    y: y
+                }
+            });
+        } else {
+            label.setAttributes({
+                x: x,
+                y: y
+            }, true);
+            if (resizing && me.animation) {
+                me.animation.on('afteranimate', function() {
+                    label.show(true);
+                });
+            } else {
+                label.show(true);
+            }
+        }
+    },
+
+    
+    highlightItem: function() {
+        var me = this;
+        me.callParent(arguments);
+        if (me.line && !me.highlighted) {
+            if (!('__strokeWidth' in me.line)) {
+                me.line.__strokeWidth = parseFloat(me.line.attr['stroke-width']) || 0;
+            }
+            if (me.line.__anim) {
+                me.line.__anim.paused = true;
+            }
+            me.line.__anim = Ext.create('Ext.fx.Anim', {
+                target: me.line,
+                to: {
+                    'stroke-width': me.line.__strokeWidth + 3
+                }
+            });
+            me.highlighted = true;
+        }
+    },
+
+    
+    unHighlightItem: function() {
+        var me = this;
+        me.callParent(arguments);
+        if (me.line && me.highlighted) {
+            me.line.__anim = Ext.create('Ext.fx.Anim', {
+                target: me.line,
+                to: {
+                    'stroke-width': me.line.__strokeWidth
+                }
+            });
+            me.highlighted = false;
+        }
+    },
+
+    
+    onPlaceCallout : function(callout, storeItem, item, i, display, animate, index) {
+        if (!display) {
+            return;
+        }
+
+        var me = this,
+            chart = me.chart,
+            surface = chart.surface,
+            resizing = chart.resizing,
+            config = me.callouts,
+            items = me.items,
+            prev = i == 0? false : items[i -1].point,
+            next = (i == items.length -1)? false : items[i +1].point,
+            cur = [+item.point[0], +item.point[1]],
+            dir, norm, normal, a, aprev, anext,
+            offsetFromViz = config.offsetFromViz || 30,
+            offsetToSide = config.offsetToSide || 10,
+            offsetBox = config.offsetBox || 3,
+            boxx, boxy, boxw, boxh,
+            p, clipRect = me.clipRect,
+            bbox = {
+                width: config.styles.width || 10,
+                height: config.styles.height || 10
+            },
+            x, y;
+
+        
+        if (!prev) {
+            prev = cur;
+        }
+        if (!next) {
+            next = cur;
+        }
+        a = (next[1] - prev[1]) / (next[0] - prev[0]);
+        aprev = (cur[1] - prev[1]) / (cur[0] - prev[0]);
+        anext = (next[1] - cur[1]) / (next[0] - cur[0]);
+
+        norm = Math.sqrt(1 + a * a);
+        dir = [1 / norm, a / norm];
+        normal = [-dir[1], dir[0]];
+
+        
+        if (aprev > 0 && anext < 0 && normal[1] < 0
+            || aprev < 0 && anext > 0 && normal[1] > 0) {
+            normal[0] *= -1;
+            normal[1] *= -1;
+        } else if (Math.abs(aprev) < Math.abs(anext) && normal[0] < 0
+                   || Math.abs(aprev) > Math.abs(anext) && normal[0] > 0) {
+            normal[0] *= -1;
+            normal[1] *= -1;
+        }
+        
+        x = cur[0] + normal[0] * offsetFromViz;
+        y = cur[1] + normal[1] * offsetFromViz;
+
+        
+        boxx = x + (normal[0] > 0? 0 : -(bbox.width + 2 * offsetBox));
+        boxy = y - bbox.height /2 - offsetBox;
+        boxw = bbox.width + 2 * offsetBox;
+        boxh = bbox.height + 2 * offsetBox;
+
+        
+        
+        if (boxx < clipRect[0] || (boxx + boxw) > (clipRect[0] + clipRect[2])) {
+            normal[0] *= -1;
+        }
+        if (boxy < clipRect[1] || (boxy + boxh) > (clipRect[1] + clipRect[3])) {
+            normal[1] *= -1;
+        }
+
+        
+        x = cur[0] + normal[0] * offsetFromViz;
+        y = cur[1] + normal[1] * offsetFromViz;
+
+        
+        boxx = x + (normal[0] > 0? 0 : -(bbox.width + 2 * offsetBox));
+        boxy = y - bbox.height /2 - offsetBox;
+        boxw = bbox.width + 2 * offsetBox;
+        boxh = bbox.height + 2 * offsetBox;
+
+        if (chart.animate) {
+            
+            me.onAnimate(callout.lines, {
+                to: {
+                    path: ["M", cur[0], cur[1], "L", x, y, "Z"]
+                }
+            });
+            
+            if (callout.panel) {
+                callout.panel.setPosition(boxx, boxy, true);
+            }
+        }
+        else {
+            
+            callout.lines.setAttributes({
+                path: ["M", cur[0], cur[1], "L", x, y, "Z"]
+            }, true);
+            
+            if (callout.panel) {
+                callout.panel.setPosition(boxx, boxy);
+            }
+        }
+        for (p in callout) {
+            callout[p].show(true);
+        }
+    },
+
+    isItemInPoint: function(x, y, item, i) {
+        var me = this,
+            items = me.items,
+            tolerance = me.selectionTolerance,
+            result = null,
+            prevItem,
+            nextItem,
+            prevPoint,
+            nextPoint,
+            ln,
+            x1,
+            y1,
+            x2,
+            y2,
+            xIntersect,
+            yIntersect,
+            dist1, dist2, dist, midx, midy,
+            sqrt = Math.sqrt, abs = Math.abs;
+
+        nextItem = items[i];
+        prevItem = i && items[i - 1];
+
+        if (i >= ln) {
+            prevItem = items[ln - 1];
+        }
+        prevPoint = prevItem && prevItem.point;
+        nextPoint = nextItem && nextItem.point;
+        x1 = prevItem ? prevPoint[0] : nextPoint[0] - tolerance;
+        y1 = prevItem ? prevPoint[1] : nextPoint[1];
+        x2 = nextItem ? nextPoint[0] : prevPoint[0] + tolerance;
+        y2 = nextItem ? nextPoint[1] : prevPoint[1];
+        dist1 = sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
+        dist2 = sqrt((x - x2) * (x - x2) + (y - y2) * (y - y2));
+        dist = Math.min(dist1, dist2);
+
+        if (dist <= tolerance) {
+            return dist == dist1? prevItem : nextItem;
+        }
+        return false;
+    },
+
+    
+    toggleAll: function(show) {
+        var me = this,
+            i, ln, shadow, shadows;
+        if (!show) {
+            Ext.chart.series.Cartesian.prototype.hideAll.call(me);
+        }
+        else {
+            Ext.chart.series.Cartesian.prototype.showAll.call(me);
+        }
+        if (me.line) {
+            me.line.setAttributes({
+                hidden: !show
+            }, true);
+            
+            if (me.line.shadows) {
+                for (i = 0, shadows = me.line.shadows, ln = shadows.length; i < ln; i++) {
+                    shadow = shadows[i];
+                    shadow.setAttributes({
+                        hidden: !show
+                    }, true);
+                }
+            }
+        }
+        if (me.fillPath) {
+            me.fillPath.setAttributes({
+                hidden: !show
+            }, true);
+        }
+    },
+
+    
+    hideAll: function() {
+        this.toggleAll(false);
+    },
+
+    
+    showAll: function() {
+        this.toggleAll(true);
+    }
+});
+
+
+Ext.define('Ext.chart.series.Pie', {
+
+    
+
+    alternateClassName: ['Ext.chart.PieSeries', 'Ext.chart.PieChart'],
+
+    extend: 'Ext.chart.series.Series',
+
+    
+
+    type: "pie",
+
+    alias: 'series.pie',
+
+    accuracy: 100000,
+
+    rad: Math.PI * 2 / 100000,
+
+    
+    highlightDuration: 150,
+
+    
+    angleField: false,
+
+    
+
+    
+
+    
+    lengthField: false,
+
+    
+    donut: false,
+
+    
+    showInLegend: false,
+
+    
+
+    
+    style: {},
+
+    constructor: function(config) {
+        this.callParent(arguments);
+        var me = this,
+            chart = me.chart,
+            surface = chart.surface,
+            store = chart.store,
+            shadow = chart.shadow, i, l, cfg;
+        config.highlightCfg = Ext.merge({
+            segment: {
+                margin: 20
+            }
+        }, config.highlightCfg);
+        Ext.apply(me, config, {
+            shadowAttributes: [{
+                "stroke-width": 6,
+                "stroke-opacity": 1,
+                stroke: 'rgb(200, 200, 200)',
+                translate: {
+                    x: 1.2,
+                    y: 2
+                }
+            },
+            {
+                "stroke-width": 4,
+                "stroke-opacity": 1,
+                stroke: 'rgb(150, 150, 150)',
+                translate: {
+                    x: 0.9,
+                    y: 1.5
+                }
+            },
+            {
+                "stroke-width": 2,
+                "stroke-opacity": 1,
+                stroke: 'rgb(100, 100, 100)',
+                translate: {
+                    x: 0.6,
+                    y: 1
+                }
+            }]
+        });
+        me.group = surface.getGroup(me.seriesId);
+        if (shadow) {
+            for (i = 0, l = me.shadowAttributes.length; i < l; i++) {
+                me.shadowGroups.push(surface.getGroup(me.seriesId + '-shadows' + i));
+            }
+        }
+        surface.customAttributes.segment = function(opt) {
+            
+            
+            
+            var ans = me.getSegment(opt);
+            if (!ans.path || ans.path.length === 0) {
+                ans.path = ['M', 0, 0];
+            }
+            return ans;
+        };
+        me.__excludes = me.__excludes || [];
+    },
+
+    
+    initialize: function() {
+        var me = this,
+            store = me.chart.getChartStore(),
+            data = store.data.items,
+            i, ln, rec;
+        
+        me.yField = [];
+        if (me.label.field) {
+            for (i = 0, ln = data.length; i < ln; i++) {
+                rec = data[i];
+                me.yField.push(rec.get(me.label.field));
+            }
+        }
+    },
+
+    
+    getSegment: function(opt) {
+        var me = this,
+            rad = me.rad,
+            cos = Math.cos,
+            sin = Math.sin,
+            x = me.centerX,
+            y = me.centerY,
+            x1 = 0, x2 = 0, x3 = 0, x4 = 0,
+            y1 = 0, y2 = 0, y3 = 0, y4 = 0,
+            x5 = 0, y5 = 0, x6 = 0, y6 = 0,
+            delta = 1e-2,
+            startAngle = opt.startAngle,
+            endAngle = opt.endAngle,
+            midAngle = (startAngle + endAngle) / 2 * rad,
+            margin = opt.margin || 0,
+            a1 = Math.min(startAngle, endAngle) * rad,
+            a2 = Math.max(startAngle, endAngle) * rad,
+            c1 = cos(a1), s1 = sin(a1),
+            c2 = cos(a2), s2 = sin(a2),
+            cm = cos(midAngle), sm = sin(midAngle),
+            flag = 0, hsqr2 = 0.7071067811865476; 
+
+        if (a2 - a1 < delta) {
+            return {path: ""};
+        }
+
+        if (margin !== 0) {
+            x += margin * cm;
+            y += margin * sm;
+        }
+
+        x2 = x + opt.endRho * c1;
+        y2 = y + opt.endRho * s1;
+
+        x4 = x + opt.endRho * c2;
+        y4 = y + opt.endRho * s2;
+
+        x6 = x + opt.endRho * cm;
+        y6 = y + opt.endRho * sm;
+
+        if (opt.startRho !== 0) {
+            x1 = x + opt.startRho * c1;
+            y1 = y + opt.startRho * s1;
+    
+            x3 = x + opt.startRho * c2;
+            y3 = y + opt.startRho * s2;
+    
+            x5 = x + opt.startRho * cm;
+            y5 = y + opt.startRho * sm;
+
+            return {
+                path: [
+                    ["M", x2, y2],
+                    ["A", opt.endRho, opt.endRho, 0, 0, 1, x6, y6], ["L", x6, y6],
+                    ["A", opt.endRho, opt.endRho, 0, flag, 1, x4, y4], ["L", x4, y4],
+                    ["L", x3, y3],
+                    ["A", opt.startRho, opt.startRho, 0, flag, 0, x5, y5], ["L", x5, y5],
+                    ["A", opt.startRho, opt.startRho, 0, 0, 0, x1, y1], ["L", x1, y1],
+                    ["Z"]
+                ]
+            };
+        } else {
+            return {
+                path: [
+                    ["M", x, y],
+                    ["L", x2, y2],
+                    ["A", opt.endRho, opt.endRho, 0, 0, 1, x6, y6], ["L", x6, y6],
+                    ["A", opt.endRho, opt.endRho, 0, flag, 1, x4, y4], ["L", x4, y4],
+                    ["L", x, y],
+                    ["Z"]
+                ]
+            };
+        }
+    },
+
+    
+    calcMiddle: function(item) {
+        var me = this,
+            rad = me.rad,
+            slice = item.slice,
+            x = me.centerX,
+            y = me.centerY,
+            startAngle = slice.startAngle,
+            endAngle = slice.endAngle,
+            donut = +me.donut,
+            midAngle = -(startAngle + endAngle) * rad / 2,
+            r = (item.endRho + item.startRho) / 2,
+            xm = x + r * Math.cos(midAngle),
+            ym = y - r * Math.sin(midAngle);
+
+        item.middle = {
+            x: xm,
+            y: ym
+        };
+    },
+
+    
+    drawSeries: function() {
+        var me = this,
+            store = me.chart.getChartStore(),
+            data = store.data.items,
+            record,
+            group = me.group,
+            animate = me.chart.animate,
+            field = me.angleField || me.field || me.xField,
+            lenField = [].concat(me.lengthField),
+            totalLenField = 0,
+            chart = me.chart,
+            surface = chart.surface,
+            chartBBox = chart.chartBBox,
+            enableShadows = chart.shadow,
+            shadowGroups = me.shadowGroups,
+            shadowAttributes = me.shadowAttributes,
+            lnsh = shadowGroups.length,
+            layers = lenField.length,
+            rhoAcum = 0,
+            donut = +me.donut,
+            layerTotals = [],
+            items = [],
+            totalField = 0,
+            maxLenField = 0,
+            angle = 0,
+            seriesStyle = me.seriesStyle,
+            colorArrayStyle = me.colorArrayStyle,
+            colorArrayLength = colorArrayStyle && colorArrayStyle.length || 0,
+            rendererAttributes,
+            shadowAttr,
+            shadows,
+            shadow,
+            shindex,
+            centerX,
+            centerY,
+            deltaRho,
+            first = 0,
+            slice,
+            slices,
+            sprite,
+            value,
+            item,
+            lenValue,
+            ln,
+            i,
+            j,
+            endAngle,
+            path,
+            p,
+            spriteOptions, bbox;
+
+        Ext.apply(seriesStyle, me.style || {});
+
+        me.setBBox();
+        bbox = me.bbox;
+
+        
+        if (me.colorSet) {
+            colorArrayStyle = me.colorSet;
+            colorArrayLength = colorArrayStyle.length;
+        }
+
+        
+        if (!store || !store.getCount() || me.seriesIsHidden) {
+            me.hide();
+            me.items = [];
+            return;
+        }
+
+        me.unHighlightItem();
+        me.cleanHighlights();
+
+        centerX = me.centerX = chartBBox.x + (chartBBox.width / 2);
+        centerY = me.centerY = chartBBox.y + (chartBBox.height / 2);
+        me.radius = Math.min(centerX - chartBBox.x, centerY - chartBBox.y);
+        me.slices = slices = [];
+        me.items = items = [];
+
+        for (i = 0, ln = data.length; i < ln; i++) {
+            record = data[i];
+            if (this.__excludes && this.__excludes[i]) {
+                
+                continue;
+            }
+            totalField += +record.get(field);
+            if (lenField[0]) {
+                for (j = 0, totalLenField = 0; j < layers; j++) {
+                    totalLenField += +record.get(lenField[j]);
+                }
+                layerTotals[i] = totalLenField;
+                maxLenField = Math.max(maxLenField, totalLenField);
+            }
+        }
+
+        totalField = totalField || 1;
+        for (i = 0, ln = data.length; i < ln; i++) {
+            record = data[i];
+            if (this.__excludes && this.__excludes[i]) {
+                value = 0;
+            } else {
+                value = record.get(field);
+                if (first == 0) {
+                    first = 1;
+                }
+            }
+
+            
+            if (first == 1) {
+                first = 2;
+                me.firstAngle = angle = me.accuracy * value / totalField / 2;
+                for (j = 0; j < i; j++) {
+                    slices[j].startAngle = slices[j].endAngle = me.firstAngle;
+                }
+            }
+
+            endAngle = angle - me.accuracy * value / totalField;
+            slice = {
+                series: me,
+                value: value,
+                startAngle: angle,
+                endAngle: endAngle,
+                storeItem: record
+            };
+            if (lenField[0]) {
+                lenValue = +layerTotals[i];
+                
+                slice.rho = Math.floor(me.radius / maxLenField * lenValue);
+            } else {
+                slice.rho = me.radius;
+            }
+            slices[i] = slice;
+            
+            (function () {
+                angle = endAngle;
+            })();
+        }
+
+        
+        if (enableShadows) {
+            for (i = 0, ln = slices.length; i < ln; i++) {
+                slice = slices[i];
+                slice.shadowAttrs = [];
+                for (j = 0, rhoAcum = 0, shadows = []; j < layers; j++) {
+                    sprite = group.getAt(i * layers + j);
+                    deltaRho = lenField[j] ? store.getAt(i).get(lenField[j]) / layerTotals[i] * slice.rho: slice.rho;
+                    
+                    rendererAttributes = {
+                        segment: {
+                            startAngle: slice.startAngle,
+                            endAngle: slice.endAngle,
+                            margin: 0,
+                            rho: slice.rho,
+                            startRho: rhoAcum + (deltaRho * donut / 100),
+                            endRho: rhoAcum + deltaRho
+                        },
+                        hidden: !slice.value && (slice.startAngle % me.accuracy) == (slice.endAngle % me.accuracy)
+                    };
+                    
+                    for (shindex = 0, shadows = []; shindex < lnsh; shindex++) {
+                        shadowAttr = shadowAttributes[shindex];
+                        shadow = shadowGroups[shindex].getAt(i);
+                        if (!shadow) {
+                            shadow = chart.surface.add(Ext.apply({}, {
+                                type: 'path',
+                                group: shadowGroups[shindex],
+                                strokeLinejoin: "round"
+                            }, rendererAttributes, shadowAttr));
+                        }
+                        shadowAttr = me.renderer(shadow, store.getAt(i), Ext.apply({}, rendererAttributes, shadowAttr), i, store);
+                        if (animate) {
+                            me.onAnimate(shadow, {
+                                to: shadowAttr
+                            });
+                        } else {
+                            shadow.setAttributes(shadowAttr, true);
+                        }
+                        shadows.push(shadow);
+                    }
+                    slice.shadowAttrs[j] = shadows;
+                }
+            }
+        }
+        
+        for (i = 0, ln = slices.length; i < ln; i++) {
+            slice = slices[i];
+            for (j = 0, rhoAcum = 0; j < layers; j++) {
+                sprite = group.getAt(i * layers + j);
+                deltaRho = lenField[j] ? store.getAt(i).get(lenField[j]) / layerTotals[i] * slice.rho: slice.rho;
+                
+                rendererAttributes = Ext.apply({
+                    segment: {
+                        startAngle: slice.startAngle,
+                        endAngle: slice.endAngle,
+                        margin: 0,
+                        rho: slice.rho,
+                        startRho: rhoAcum + (deltaRho * donut / 100),
+                        endRho: rhoAcum + deltaRho
+                    },
+                    hidden: (!slice.value && (slice.startAngle % me.accuracy) == (slice.endAngle % me.accuracy))
+                }, Ext.apply(seriesStyle, colorArrayStyle && { fill: colorArrayStyle[(layers > 1? j : i) % colorArrayLength] } || {}));
+                item = Ext.apply({},
+                rendererAttributes.segment, {
+                    slice: slice,
+                    series: me,
+                    storeItem: slice.storeItem,
+                    index: i
+                });
+                me.calcMiddle(item);
+                if (enableShadows) {
+                    item.shadows = slice.shadowAttrs[j];
+                }
+                items[i] = item;
+                
+                if (!sprite) {
+                    spriteOptions = Ext.apply({
+                        type: "path",
+                        group: group,
+                        middle: item.middle
+                    }, Ext.apply(seriesStyle, colorArrayStyle && { fill: colorArrayStyle[(layers > 1? j : i) % colorArrayLength] } || {}));
+                    sprite = surface.add(Ext.apply(spriteOptions, rendererAttributes));
+                }
+                slice.sprite = slice.sprite || [];
+                item.sprite = sprite;
+                slice.sprite.push(sprite);
+                slice.point = [item.middle.x, item.middle.y];
+                if (animate) {
+                    rendererAttributes = me.renderer(sprite, store.getAt(i), rendererAttributes, i, store);
+                    sprite._to = rendererAttributes;
+                    sprite._animating = true;
+                    me.onAnimate(sprite, {
+                        to: rendererAttributes,
+                        listeners: {
+                            afteranimate: {
+                                fn: function() {
+                                    this._animating = false;
+                                },
+                                scope: sprite
+                            }
+                        }
+                    });
+                } else {
+                    rendererAttributes = me.renderer(sprite, store.getAt(i), Ext.apply(rendererAttributes, {
+                        hidden: false
+                    }), i, store);
+                    sprite.setAttributes(rendererAttributes, true);
+                }
+                rhoAcum += deltaRho;
+            }
+        }
+
+        
+        ln = group.getCount();
+        for (i = 0; i < ln; i++) {
+            if (!slices[(i / layers) >> 0] && group.getAt(i)) {
+                group.getAt(i).hide(true);
+            }
+        }
+        if (enableShadows) {
+            lnsh = shadowGroups.length;
+            for (shindex = 0; shindex < ln; shindex++) {
+                if (!slices[(shindex / layers) >> 0]) {
+                    for (j = 0; j < lnsh; j++) {
+                        if (shadowGroups[j].getAt(shindex)) {
+                            shadowGroups[j].getAt(shindex).hide(true);
+                        }
+                    }
+                }
+            }
+        }
+        me.renderLabels();
+        me.renderCallouts();
+    },
+
+    
+    onCreateLabel: function(storeItem, item, i, display) {
+        var me = this,
+            group = me.labelsGroup,
+            config = me.label,
+            centerX = me.centerX,
+            centerY = me.centerY,
+            middle = item.middle,
+            endLabelStyle = Ext.apply(me.seriesLabelStyle || {}, config || {});
+
+        return me.chart.surface.add(Ext.apply({
+            'type': 'text',
+            'text-anchor': 'middle',
+            'group': group,
+            'x': middle.x,
+            'y': middle.y
+        }, endLabelStyle));
+    },
+
+    
+    onPlaceLabel: function(label, storeItem, item, i, display, animate, index) {
+        var me = this,
+            chart = me.chart,
+            resizing = chart.resizing,
+            config = me.label,
+            format = config.renderer,
+            field = [].concat(config.field),
+            centerX = me.centerX,
+            centerY = me.centerY,
+            middle = item.middle,
+            opt = {
+                x: middle.x,
+                y: middle.y
+            },
+            x = middle.x - centerX,
+            y = middle.y - centerY,
+            from = {},
+            rho = 1,
+            theta = Math.atan2(y, x || 1),
+            dg = theta * 180 / Math.PI,
+            prevDg;
+
+        opt.hidden = false;
+
+        if (this.__excludes && this.__excludes[i]) {
+            opt.hidden = true;
+        }
+
+        function fixAngle(a) {
+            if (a < 0) {
+                a += 360;
+            }
+            return a % 360;
+        }
+
+        label.setAttributes({
+            text: format(storeItem.get(field[index]))
+        }, true);
+
+        switch (display) {
+        case 'outside':
+            rho = Math.sqrt(x * x + y * y) * 2;
+            
+            opt.x = rho * Math.cos(theta) + centerX;
+            opt.y = rho * Math.sin(theta) + centerY;
+            break;
+
+        case 'rotate':
+            dg = fixAngle(dg);
+            dg = (dg > 90 && dg < 270) ? dg + 180: dg;
+
+            prevDg = label.attr.rotation.degrees;
+            if (prevDg != null && Math.abs(prevDg - dg) > 180 * 0.5) {
+                if (dg > prevDg) {
+                    dg -= 360;
+                } else {
+                    dg += 360;
+                }
+                dg = dg % 360;
+            } else {
+                dg = fixAngle(dg);
+            }
+            
+            opt.rotate = {
+                degrees: dg,
+                x: opt.x,
+                y: opt.y
+            };
+            break;
+
+        default:
+            break;
+        }
+        
+        opt.translate = {
+            x: 0, y: 0
+        };
+        if (animate && !resizing && (display != 'rotate' || prevDg != null)) {
+            me.onAnimate(label, {
+                to: opt
+            });
+        } else {
+            label.setAttributes(opt, true);
+        }
+        label._from = from;
+    },
+
+    
+    onPlaceCallout: function(callout, storeItem, item, i, display, animate, index) {
+        var me = this,
+            chart = me.chart,
+            centerX = me.centerX,
+            centerY = me.centerY,
+            middle = item.middle,
+            opt = {
+                x: middle.x,
+                y: middle.y
+            },
+            x = middle.x - centerX,
+            y = middle.y - centerY,
+            rho = 1,
+            rhoCenter,
+            theta = Math.atan2(y, x || 1),
+            bbox = callout.label.getBBox(),
+            offsetFromViz = 20,
+            offsetToSide = 10,
+            offsetBox = 10,
+            p;
+
+        
+        rho = item.endRho + offsetFromViz;
+        rhoCenter = (item.endRho + item.startRho) / 2 + (item.endRho - item.startRho) / 3;
+        
+        opt.x = rho * Math.cos(theta) + centerX;
+        opt.y = rho * Math.sin(theta) + centerY;
+
+        x = rhoCenter * Math.cos(theta);
+        y = rhoCenter * Math.sin(theta);
+
+        if (chart.animate) {
+            
+            me.onAnimate(callout.lines, {
+                to: {
+                    path: ["M", x + centerX, y + centerY, "L", opt.x, opt.y, "Z", "M", opt.x, opt.y, "l", x > 0 ? offsetToSide: -offsetToSide, 0, "z"]
+                }
+            });
+            
+            me.onAnimate(callout.box, {
+                to: {
+                    x: opt.x + (x > 0 ? offsetToSide: -(offsetToSide + bbox.width + 2 * offsetBox)),
+                    y: opt.y + (y > 0 ? ( - bbox.height - offsetBox / 2) : ( - bbox.height - offsetBox / 2)),
+                    width: bbox.width + 2 * offsetBox,
+                    height: bbox.height + 2 * offsetBox
+                }
+            });
+            
+            me.onAnimate(callout.label, {
+                to: {
+                    x: opt.x + (x > 0 ? (offsetToSide + offsetBox) : -(offsetToSide + bbox.width + offsetBox)),
+                    y: opt.y + (y > 0 ? -bbox.height / 4: -bbox.height / 4)
+                }
+            });
+        } else {
+            
+            callout.lines.setAttributes({
+                path: ["M", x + centerX, y + centerY, "L", opt.x, opt.y, "Z", "M", opt.x, opt.y, "l", x > 0 ? offsetToSide: -offsetToSide, 0, "z"]
+            },
+            true);
+            
+            callout.box.setAttributes({
+                x: opt.x + (x > 0 ? offsetToSide: -(offsetToSide + bbox.width + 2 * offsetBox)),
+                y: opt.y + (y > 0 ? ( - bbox.height - offsetBox / 2) : ( - bbox.height - offsetBox / 2)),
+                width: bbox.width + 2 * offsetBox,
+                height: bbox.height + 2 * offsetBox
+            },
+            true);
+            
+            callout.label.setAttributes({
+                x: opt.x + (x > 0 ? (offsetToSide + offsetBox) : -(offsetToSide + bbox.width + offsetBox)),
+                y: opt.y + (y > 0 ? -bbox.height / 4: -bbox.height / 4)
+            },
+            true);
+        }
+        for (p in callout) {
+            callout[p].show(true);
+        }
+    },
+
+    
+    onAnimate: function(sprite, attr) {
+        sprite.show();
+        return this.callParent(arguments);
+    },
+
+    isItemInPoint: function(x, y, item, i) {
+        var me = this,
+            cx = me.centerX,
+            cy = me.centerY,
+            abs = Math.abs,
+            dx = abs(x - cx),
+            dy = abs(y - cy),
+            startAngle = item.startAngle,
+            endAngle = item.endAngle,
+            rho = Math.sqrt(dx * dx + dy * dy),
+            angle = Math.atan2(y - cy, x - cx) / me.rad;
+
+        
+        if (angle > me.firstAngle) {
+            angle -= me.accuracy;
+        }
+        return (angle <= startAngle && angle > endAngle
+                && rho >= item.startRho && rho <= item.endRho);
+    },
+
+    
+    hideAll: function(index) {
+        var i, l, shadow, shadows, sh, lsh, sprite;
+        index = (isNaN(this._index) ? index : this._index) || 0;
+        this.__excludes = this.__excludes || [];
+        this.__excludes[index] = true;
+        sprite = this.slices[index].sprite;
+        for (sh = 0, lsh = sprite.length; sh < lsh; sh++) {
+            sprite[sh].setAttributes({
+                hidden: true
+            }, true);
+        }
+        if (this.slices[index].shadowAttrs) {
+            for (i = 0, shadows = this.slices[index].shadowAttrs, l = shadows.length; i < l; i++) {
+                shadow = shadows[i];
+                for (sh = 0, lsh = shadow.length; sh < lsh; sh++) {
+                    shadow[sh].setAttributes({
+                        hidden: true
+                    }, true);
+                }
+            }
+        }
+        this.drawSeries();
+    },
+
+    
+    showAll: function(index) {
+        index = (isNaN(this._index) ? index : this._index) || 0;
+        this.__excludes[index] = false;
+        this.drawSeries();
+    },
+
+    
+    highlightItem: function(item) {
+        var me = this,
+            rad = me.rad,
+            highlightSegment,
+            animate,
+            attrs,
+            i,
+            shadows,
+            shadow,
+            ln,
+            to,
+            itemHighlightSegment,
+            prop,
+            group,
+            display,
+            label,
+            middle,
+            r,
+            x,
+            y;
+        item = item || this.items[this._index];
+
+        
+        
+        
+        
+        this.unHighlightItem();
+
+        if (!item || me.animating || (item.sprite && item.sprite._animating)) {
+            return;
+        }
+        me.callParent([item]);
+        if (!me.highlight) {
+            return;
+        }
+        if ('segment' in me.highlightCfg) {
+            highlightSegment = me.highlightCfg.segment;
+            animate = me.chart.animate;
+            
+            if (me.labelsGroup) {
+                group = me.labelsGroup;
+                display = me.label.display;
+                label = group.getAt(item.index);
+                middle = (item.startAngle + item.endAngle) / 2 * rad;
+                r = highlightSegment.margin || 0;
+                x = r * Math.cos(middle);
+                y = r * Math.sin(middle);
+
+                
+                
+                
+                
+                
+                if (Math.abs(x) < 1e-10) {
+                    x = 0;
+                }
+                if (Math.abs(y) < 1e-10) {
+                    y = 0;
+                }
+
+                if (animate) {
+                    label.stopAnimation();
+                    label.animate({
+                        to: {
+                            translate: {
+                                x: x,
+                                y: y
+                            }
+                        },
+                        duration: me.highlightDuration
+                    });
+                }
+                else {
+                    label.setAttributes({
+                        translate: {
+                            x: x,
+                            y: y
+                        }
+                    }, true);
+                }
+            }
+            
+            if (me.chart.shadow && item.shadows) {
+                i = 0;
+                shadows = item.shadows;
+                ln = shadows.length;
+                for (; i < ln; i++) {
+                    shadow = shadows[i];
+                    to = {};
+                    itemHighlightSegment = item.sprite._from.segment;
+                    for (prop in itemHighlightSegment) {
+                        if (! (prop in highlightSegment)) {
+                            to[prop] = itemHighlightSegment[prop];
+                        }
+                    }
+                    attrs = {
+                        segment: Ext.applyIf(to, me.highlightCfg.segment)
+                    };
+                    if (animate) {
+                        shadow.stopAnimation();
+                        shadow.animate({
+                            to: attrs,
+                            duration: me.highlightDuration
+                        });
+                    }
+                    else {
+                        shadow.setAttributes(attrs, true);
+                    }
+                }
+            }
+        }
+    },
+
+    
+    unHighlightItem: function() {
+        var me = this,
+            items,
+            animate,
+            shadowsEnabled,
+            group,
+            len,
+            i,
+            j,
+            display,
+            shadowLen,
+            p,
+            to,
+            ihs,
+            hs,
+            sprite,
+            shadows,
+            shadow,
+            item,
+            label,
+            attrs;
+        if (!me.highlight) {
+            return;
+        }
+
+        if (('segment' in me.highlightCfg) && me.items) {
+            items = me.items;
+            animate = me.chart.animate;
+            shadowsEnabled = !!me.chart.shadow;
+            group = me.labelsGroup;
+            len = items.length;
+            i = 0;
+            j = 0;
+            display = me.label.display;
+
+            for (; i < len; i++) {
+                item = items[i];
+                if (!item) {
+                    continue;
+                }
+                sprite = item.sprite;
+                if (sprite && sprite._highlighted) {
+                    
+                    if (group) {
+                        label = group.getAt(item.index);
+                        attrs = Ext.apply({
+                            translate: {
+                                x: 0,
+                                y: 0
+                            }
+                        },
+                        display == 'rotate' ? {
+                            rotate: {
+                                x: label.attr.x,
+                                y: label.attr.y,
+                                degrees: label.attr.rotation.degrees
+                            }
+                        }: {});
+                        if (animate) {
+                            label.stopAnimation();
+                            label.animate({
+                                to: attrs,
+                                duration: me.highlightDuration
+                            });
+                        }
+                        else {
+                            label.setAttributes(attrs, true);
+                        }
+                    }
+                    if (shadowsEnabled) {
+                        shadows = item.shadows;
+                        shadowLen = shadows.length;
+                        for (; j < shadowLen; j++) {
+                            to = {};
+                            ihs = item.sprite._to.segment;
+                            hs = item.sprite._from.segment;
+                            Ext.apply(to, hs);
+                            for (p in ihs) {
+                                if (! (p in hs)) {
+                                    to[p] = ihs[p];
+                                }
+                            }
+                            shadow = shadows[j];
+                            if (animate) {
+                                shadow.stopAnimation();
+                                shadow.animate({
+                                    to: {
+                                        segment: to
+                                    },
+                                    duration: me.highlightDuration
+                                });
+                            }
+                            else {
+                                shadow.setAttributes({ segment: to }, true);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        me.callParent(arguments);
+    },
+
+    
+    getLegendColor: function(index) {
+        var me = this;
+        return (me.colorSet && me.colorSet[index % me.colorSet.length]) || me.colorArrayStyle[index % me.colorArrayStyle.length];
+    }
+});
+
+
+
+Ext.define('Ext.chart.series.Radar', {
+
+    
+
+    extend: 'Ext.chart.series.Series',
+
+    requires: ['Ext.chart.Shape', 'Ext.fx.Anim'],
+
+    
+
+    type: "radar",
+    alias: 'series.radar',
+
+
+    rad: Math.PI / 180,
+
+    showInLegend: false,
+
+    
+    style: {},
+
+    constructor: function(config) {
+        this.callParent(arguments);
+        var me = this,
+            surface = me.chart.surface, i, l;
+        me.group = surface.getGroup(me.seriesId);
+        if (me.showMarkers) {
+            me.markerGroup = surface.getGroup(me.seriesId + '-markers');
+        }
+    },
+
+    
+    drawSeries: function() {
+        var me = this,
+            store = me.chart.getChartStore(),
+            data = store.data.items,
+            d, record,
+            group = me.group,
+            sprite,
+            chart = me.chart,
+            seriesItems = chart.series.items,
+            s, sLen, series,
+            animate = chart.animate,
+            field = me.field || me.yField,
+            surface = chart.surface,
+            chartBBox = chart.chartBBox,
+            seriesIdx = me.seriesIdx,
+            colorArrayStyle = me.colorArrayStyle,
+            centerX, centerY,
+            items,
+            radius,
+            maxValue = 0,
+            fields = [],
+            max = Math.max,
+            cos = Math.cos,
+            sin = Math.sin,
+            pi2 = Math.PI * 2,
+            l = store.getCount(),
+            startPath, path, x, y, rho,
+            i, nfields,
+            seriesStyle = me.seriesStyle,
+            seriesLabelStyle = me.seriesLabelStyle,
+            first = chart.resizing || !me.radar,
+            axis = chart.axes && chart.axes.get(0),
+            aggregate = !(axis && axis.maximum);
+
+        me.setBBox();
+        
+        maxValue = aggregate? 0 : (axis.maximum || 0);
+        
+        Ext.apply(seriesStyle, me.style || {});
+
+        
+        if (!store || !store.getCount() || me.seriesIsHidden) {
+            me.hide();
+            me.items = [];
+            if (me.radar) {
+                me.radar.hide(true);
+            }
+            me.radar = null;
+            return;
+        }
+        
+        if(!seriesStyle['stroke']){
+            seriesStyle['stroke'] = colorArrayStyle[seriesIdx % colorArrayStyle.length];
+        }
+
+        me.unHighlightItem();
+        me.cleanHighlights();
+
+        centerX = me.centerX = chartBBox.x + (chartBBox.width / 2);
+        centerY = me.centerY = chartBBox.y + (chartBBox.height / 2);
+        me.radius = radius = Math.min(chartBBox.width, chartBBox.height) /2;
+        me.items = items = [];
+
+        if (aggregate) {
+            
+            for (s = 0, sLen = seriesItems.length; s < sLen; s++) {
+                series = seriesItems[s];
+                fields.push(series.yField);
+            }
+            
+            for (d = 0; d < l; d++) {
+                record = data[d];
+                for (i = 0, nfields = fields.length; i < nfields; i++) {
+                    maxValue = max(+record.get(fields[i]), maxValue);
+                }
+            }
+        }
+        
+        maxValue = maxValue || 1;
+        
+        startPath = []; path = [];
+        for (i = 0; i < l; i++) {
+            record = data[i];
+            rho = radius * record.get(field) / maxValue;
+            x = rho * cos(i / l * pi2);
+            y = rho * sin(i / l * pi2);
+            if (i == 0) {
+                path.push('M', x + centerX, y + centerY);
+                startPath.push('M', 0.01 * x + centerX, 0.01 * y + centerY);
+            } else {
+                path.push('L', x + centerX, y + centerY);
+                startPath.push('L', 0.01 * x + centerX, 0.01 * y + centerY);
+            }
+            items.push({
+                sprite: false, 
+                point: [centerX + x, centerY + y],
+                storeItem: record,
+                series: me
+            });
+        }
+        path.push('Z');
+        
+        if (!me.radar) {
+            me.radar = surface.add(Ext.apply({
+                type: 'path',
+                group: group,
+                path: startPath
+            }, seriesStyle || {}));
+        }
+        
+        if (chart.resizing) {
+            me.radar.setAttributes({
+                path: startPath
+            }, true);
+        }
+        
+        if (chart.animate) {
+            me.onAnimate(me.radar, {
+                to: Ext.apply({
+                    path: path
+                }, seriesStyle || {})
+            });
+        } else {
+            me.radar.setAttributes(Ext.apply({
+                path: path
+            }, seriesStyle || {}), true);
+        }
+        
+        if (me.showMarkers) {
+            me.drawMarkers();
+        }
+        me.renderLabels();
+        me.renderCallouts();
+    },
+
+    
+    drawMarkers: function() {
+        var me = this,
+            chart = me.chart,
+            surface = chart.surface,
+            markerStyle = Ext.apply({}, me.markerStyle || {}),
+            endMarkerStyle = Ext.apply(markerStyle, me.markerConfig, {
+                fill: me.colorArrayStyle[me.seriesIdx % me.colorArrayStyle.length]
+            }),
+            items = me.items,
+            type = endMarkerStyle.type,
+            markerGroup = me.markerGroup,
+            centerX = me.centerX,
+            centerY = me.centerY,
+            item, i, l, marker;
+        delete endMarkerStyle.type;
+
+        for (i = 0, l = items.length; i < l; i++) {
+            item = items[i];
+            marker = markerGroup.getAt(i);
+            if (!marker) {
+                marker = Ext.chart.Shape[type](surface, Ext.apply({
+                    group: markerGroup,
+                    x: 0,
+                    y: 0,
+                    translate: {
+                        x: centerX,
+                        y: centerY
+                    }
+                }, endMarkerStyle));
+            }
+            else {
+                marker.show();
+            }
+            item.sprite = marker;
+            if (chart.resizing) {
+                marker.setAttributes({
+                    x: 0,
+                    y: 0,
+                    translate: {
+                        x: centerX,
+                        y: centerY
+                    }
+                }, true);
+            }
+            marker._to = {
+                translate: {
+                    x: item.point[0],
+                    y: item.point[1]
+                }
+            };
+            
+            if (chart.animate) {
+                me.onAnimate(marker, {
+                    to: marker._to
+                });
+            }
+            else {
+                marker.setAttributes(Ext.apply(marker._to, endMarkerStyle || {}), true);
+            }
+        }
+    },
+
+    isItemInPoint: function(x, y, item) {
+        var point,
+            tolerance = 10,
+            abs = Math.abs;
+        point = item.point;
+        return (abs(point[0] - x) <= tolerance &&
+                abs(point[1] - y) <= tolerance);
+    },
+
+    
+    onCreateLabel: function(storeItem, item, i, display) {
+        var me = this,
+            group = me.labelsGroup,
+            config = me.label,
+            centerX = me.centerX,
+            centerY = me.centerY,
+            point = item.point,
+            endLabelStyle = Ext.apply(me.seriesLabelStyle || {}, config);
+
+        return me.chart.surface.add(Ext.apply({
+            'type': 'text',
+            'text-anchor': 'middle',
+            'group': group,
+            'x': centerX,
+            'y': centerY
+        }, config || {}));
+    },
+
+    
+    onPlaceLabel: function(label, storeItem, item, i, display, animate) {
+        var me = this,
+            chart = me.chart,
+            resizing = chart.resizing,
+            config = me.label,
+            format = config.renderer,
+            field = config.field,
+            centerX = me.centerX,
+            centerY = me.centerY,
+            opt = {
+                x: item.point[0],
+                y: item.point[1]
+            },
+            x = opt.x - centerX,
+            y = opt.y - centerY;
+
+        label.setAttributes({
+            text: format(storeItem.get(field)),
+            hidden: true
+        },
+        true);
+
+        if (resizing) {
+            label.setAttributes({
+                x: centerX,
+                y: centerY
+            }, true);
+        }
+
+        if (animate) {
+            label.show(true);
+            me.onAnimate(label, {
+                to: opt
+            });
+        } else {
+            label.setAttributes(opt, true);
+            label.show(true);
+        }
+    },
+
+    
+    toggleAll: function(show) {
+        var me = this,
+            i, ln, shadow, shadows;
+        if (!show) {
+            Ext.chart.series.Radar.superclass.hideAll.call(me);
+        }
+        else {
+            Ext.chart.series.Radar.superclass.showAll.call(me);
+        }
+        if (me.radar) {
+            me.radar.setAttributes({
+                hidden: !show
+            }, true);
+            
+            if (me.radar.shadows) {
+                for (i = 0, shadows = me.radar.shadows, ln = shadows.length; i < ln; i++) {
+                    shadow = shadows[i];
+                    shadow.setAttributes({
+                        hidden: !show
+                    }, true);
+                }
+            }
+        }
+    },
+
+    
+    hideAll: function() {
+        this.toggleAll(false);
+        this.hideMarkers(0);
+    },
+
+    
+    showAll: function() {
+        this.toggleAll(true);
+    },
+
+    
+    hideMarkers: function(index) {
+        var me = this,
+            count = me.markerGroup && me.markerGroup.getCount() || 0,
+            i = index || 0;
+        for (; i < count; i++) {
+            me.markerGroup.getAt(i).hide(true);
+        }
+    }
+});
+
+
+
+Ext.define('Ext.chart.series.Scatter', {
+
+    
+
+    extend: 'Ext.chart.series.Cartesian',
+
+    requires: ['Ext.chart.axis.Axis', 'Ext.chart.Shape', 'Ext.fx.Anim'],
+
+    
+
+    type: 'scatter',
+    alias: 'series.scatter',
+
+    
+
+    
+    
+    
+
+    constructor: function(config) {
+        this.callParent(arguments);
+        var me = this,
+            shadow = me.chart.shadow,
+            surface = me.chart.surface, i, l;
+        Ext.apply(me, config, {
+            style: {},
+            markerConfig: {},
+            shadowAttributes: [{
+                "stroke-width": 6,
+                "stroke-opacity": 0.05,
+                stroke: 'rgb(0, 0, 0)'
+            }, {
+                "stroke-width": 4,
+                "stroke-opacity": 0.1,
+                stroke: 'rgb(0, 0, 0)'
+            }, {
+                "stroke-width": 2,
+                "stroke-opacity": 0.15,
+                stroke: 'rgb(0, 0, 0)'
+            }]
+        });
+        me.group = surface.getGroup(me.seriesId);
+        if (shadow) {
+            for (i = 0, l = me.shadowAttributes.length; i < l; i++) {
+                me.shadowGroups.push(surface.getGroup(me.seriesId + '-shadows' + i));
+            }
+        }
+    },
+
+    
+    getBounds: function() {
+        var me = this,
+            chart = me.chart,
+            store = chart.getChartStore(),
+            chartAxes = chart.axes,
+            boundAxes = me.getAxesForXAndYFields(),
+            boundXAxis = boundAxes.xAxis,
+            boundYAxis = boundAxes.yAxis,
+            bbox, xScale, yScale, ln, minX, minY, maxX, maxY, i, axis, ends;
+
+        me.setBBox();
+        bbox = me.bbox;
+
+        if (axis = chartAxes.get(boundXAxis)) {
+            ends = axis.applyData();
+            minX = ends.from;
+            maxX = ends.to;
+        }
+
+        if (axis = chartAxes.get(boundYAxis)) {
+            ends = axis.applyData();
+            minY = ends.from;
+            maxY = ends.to;
+        }
+
+        
+        if (me.xField && !Ext.isNumber(minX)) {
+            axis = me.getMinMaxXValues();
+            minX = axis[0];
+            maxX = axis[1];
+        }
+
+        if (me.yField && !Ext.isNumber(minY)) {
+            axis = me.getMinMaxYValues();
+            minY = axis[0];
+            maxY = axis[1];
+        }
+
+        if (isNaN(minX)) {
+            minX = 0;
+            maxX = store.getCount() - 1;
+            xScale = bbox.width / (store.getCount() - 1);
+        }
+        else {
+            xScale = bbox.width / (maxX - minX);
+        }
+
+        if (isNaN(minY)) {
+            minY = 0;
+            maxY = store.getCount() - 1;
+            yScale = bbox.height / (store.getCount() - 1);
+        }
+        else {
+            yScale = bbox.height / (maxY - minY);
+        }
+
+        return {
+            bbox: bbox,
+            minX: minX,
+            minY: minY,
+            xScale: xScale,
+            yScale: yScale
+        };
+    },
+
+    
+    getPaths: function() {
+        var me = this,
+            chart = me.chart,
+            enableShadows = chart.shadow,
+            store = chart.getChartStore(),
+            data = store.data.items,
+            i, ln, record,
+            group = me.group,
+            bounds = me.bounds = me.getBounds(),
+            bbox = me.bbox,
+            xScale = bounds.xScale,
+            yScale = bounds.yScale,
+            minX = bounds.minX,
+            minY = bounds.minY,
+            boxX = bbox.x,
+            boxY = bbox.y,
+            boxHeight = bbox.height,
+            items = me.items = [],
+            attrs = [],
+            x, y, xValue, yValue, sprite;
+
+        for (i = 0, ln = data.length; i < ln; i++) {
+            record = data[i];
+            xValue = record.get(me.xField);
+            yValue = record.get(me.yField);
+            
+            if (typeof yValue == 'undefined' || (typeof yValue == 'string' && !yValue)
+                || xValue == null || yValue == null) {
+                continue;
+            }
+            
+            if (typeof xValue == 'string' || typeof xValue == 'object' && !Ext.isDate(xValue)) {
+                xValue = i;
+            }
+            if (typeof yValue == 'string' || typeof yValue == 'object' && !Ext.isDate(yValue)) {
+                yValue = i;
+            }
+            x = boxX + (xValue - minX) * xScale;
+            y = boxY + boxHeight - (yValue - minY) * yScale;
+            attrs.push({
+                x: x,
+                y: y
+            });
+
+            me.items.push({
+                series: me,
+                value: [xValue, yValue],
+                point: [x, y],
+                storeItem: record
+            });
+
+            
+            if (chart.animate && chart.resizing) {
+                sprite = group.getAt(i);
+                if (sprite) {
+                    me.resetPoint(sprite);
+                    if (enableShadows) {
+                        me.resetShadow(sprite);
+                    }
+                }
+            }
+        }
+        return attrs;
+    },
+
+    
+    resetPoint: function(sprite) {
+        var bbox = this.bbox;
+        sprite.setAttributes({
+            translate: {
+                x: (bbox.x + bbox.width) / 2,
+                y: (bbox.y + bbox.height) / 2
+            }
+        }, true);
+    },
+
+    
+    resetShadow: function(sprite) {
+        var me = this,
+            shadows = sprite.shadows,
+            shadowAttributes = me.shadowAttributes,
+            ln = me.shadowGroups.length,
+            bbox = me.bbox,
+            i, attr;
+        for (i = 0; i < ln; i++) {
+            attr = Ext.apply({}, shadowAttributes[i]);
+            
+            if (attr.translate) {
+                attr.translate.x += (bbox.x + bbox.width) / 2;
+                attr.translate.y += (bbox.y + bbox.height) / 2;
+            }
+            else {
+                attr.translate = {
+                    x: (bbox.x + bbox.width) / 2,
+                    y: (bbox.y + bbox.height) / 2
+                };
+            }
+            shadows[i].setAttributes(attr, true);
+        }
+    },
+
+    
+    createPoint: function(attr, type) {
+        var me = this,
+            chart = me.chart,
+            group = me.group,
+            bbox = me.bbox;
+
+        return Ext.chart.Shape[type](chart.surface, Ext.apply({}, {
+            x: 0,
+            y: 0,
+            group: group,
+            translate: {
+                x: (bbox.x + bbox.width) / 2,
+                y: (bbox.y + bbox.height) / 2
+            }
+        }, attr));
+    },
+
+    
+    createShadow: function(sprite, endMarkerStyle, type) {
+        var me = this,
+            chart = me.chart,
+            shadowGroups = me.shadowGroups,
+            shadowAttributes = me.shadowAttributes,
+            lnsh = shadowGroups.length,
+            bbox = me.bbox,
+            i, shadow, shadows, attr;
+
+        sprite.shadows = shadows = [];
+
+        for (i = 0; i < lnsh; i++) {
+            attr = Ext.apply({}, shadowAttributes[i]);
+            if (attr.translate) {
+                attr.translate.x += (bbox.x + bbox.width) / 2;
+                attr.translate.y += (bbox.y + bbox.height) / 2;
+            }
+            else {
+                Ext.apply(attr, {
+                    translate: {
+                        x: (bbox.x + bbox.width) / 2,
+                        y: (bbox.y + bbox.height) / 2
+                    }
+                });
+            }
+            Ext.apply(attr, endMarkerStyle);
+            shadow = Ext.chart.Shape[type](chart.surface, Ext.apply({}, {
+                x: 0,
+                y: 0,
+                group: shadowGroups[i]
+            }, attr));
+            shadows.push(shadow);
+        }
+    },
+
+    
+    drawSeries: function() {
+        var me = this,
+            chart = me.chart,
+            store = chart.getChartStore(),
+            group = me.group,
+            enableShadows = chart.shadow,
+            shadowGroups = me.shadowGroups,
+            shadowAttributes = me.shadowAttributes,
+            lnsh = shadowGroups.length,
+            sprite, attrs, attr, ln, i, endMarkerStyle, shindex, type, shadows,
+            rendererAttributes, shadowAttribute;
+
+        endMarkerStyle = Ext.apply(me.markerStyle, me.markerConfig);
+        type = endMarkerStyle.type;
+        delete endMarkerStyle.type;
+
+        
+        if (!store || !store.getCount()) {
+            me.hide();
+            me.items = [];
+            return;
+        }
+
+
+        me.unHighlightItem();
+        me.cleanHighlights();
+
+        attrs = me.getPaths();
+        ln = attrs.length;
+        for (i = 0; i < ln; i++) {
+            attr = attrs[i];
+            sprite = group.getAt(i);
+            Ext.apply(attr, endMarkerStyle);
+
+            
+            if (!sprite) {
+                sprite = me.createPoint(attr, type);
+                if (enableShadows) {
+                    me.createShadow(sprite, endMarkerStyle, type);
+                }
+            }
+
+            shadows = sprite.shadows;
+            if (chart.animate) {
+                rendererAttributes = me.renderer(sprite, store.getAt(i), { translate: attr }, i, store);
+                sprite._to = rendererAttributes;
+                me.onAnimate(sprite, {
+                    to: rendererAttributes
+                });
+                
+                for (shindex = 0; shindex < lnsh; shindex++) {
+                    shadowAttribute = Ext.apply({}, shadowAttributes[shindex]);
+                    rendererAttributes = me.renderer(shadows[shindex], store.getAt(i), Ext.apply({}, { 
+                        hidden: false,
+                        translate: {
+                            x: attr.x + (shadowAttribute.translate? shadowAttribute.translate.x : 0),
+                            y: attr.y + (shadowAttribute.translate? shadowAttribute.translate.y : 0)
+                        }
+                    }, shadowAttribute), i, store);
+                    me.onAnimate(shadows[shindex], { to: rendererAttributes });
+                }
+            }
+            else {
+                rendererAttributes = me.renderer(sprite, store.getAt(i), { translate: attr }, i, store);
+                sprite._to = rendererAttributes;
+                sprite.setAttributes(rendererAttributes, true);
+                
+                for (shindex = 0; shindex < lnsh; shindex++) {
+                    shadowAttribute = Ext.apply({}, shadowAttributes[shindex]);
+                    rendererAttributes = me.renderer(shadows[shindex], store.getAt(i), Ext.apply({}, { 
+                        hidden: false,
+                        translate: {
+                            x: attr.x + (shadowAttribute.translate? shadowAttribute.translate.x : 0),
+                            y: attr.y + (shadowAttribute.translate? shadowAttribute.translate.y : 0)
+                        } 
+                    }, shadowAttribute), i, store);
+                    shadows[shindex].setAttributes(rendererAttributes, true);
+                }
+            }
+            me.items[i].sprite = sprite;
+        }
+
+        
+        ln = group.getCount();
+        for (i = attrs.length; i < ln; i++) {
+            group.getAt(i).hide(true);
+        }
+        me.renderLabels();
+        me.renderCallouts();
+    },
+
+    
+    onCreateLabel: function(storeItem, item, i, display) {
+        var me = this,
+            group = me.labelsGroup,
+            config = me.label,
+            endLabelStyle = Ext.apply({}, config, me.seriesLabelStyle),
+            bbox = me.bbox;
+
+        return me.chart.surface.add(Ext.apply({
+            type: 'text',
+            group: group,
+            x: item.point[0],
+            y: bbox.y + bbox.height / 2
+        }, endLabelStyle));
+    },
+
+    
+    onPlaceLabel: function(label, storeItem, item, i, display, animate) {
+        var me = this,
+            chart = me.chart,
+            resizing = chart.resizing,
+            config = me.label,
+            format = config.renderer,
+            field = config.field,
+            bbox = me.bbox,
+            x = item.point[0],
+            y = item.point[1],
+            radius = item.sprite.attr.radius,
+            bb, width, height, anim;
+
+        label.setAttributes({
+            text: format(storeItem.get(field)),
+            hidden: true
+        }, true);
+
+        if (display == 'rotate') {
+            label.setAttributes({
+                'text-anchor': 'start',
+                'rotation': {
+                    x: x,
+                    y: y,
+                    degrees: -45
+                }
+            }, true);
+            
+            bb = label.getBBox();
+            width = bb.width;
+            height = bb.height;
+            x = x < bbox.x? bbox.x : x;
+            x = (x + width > bbox.x + bbox.width)? (x - (x + width - bbox.x - bbox.width)) : x;
+            y = (y - height < bbox.y)? bbox.y + height : y;
+
+        } else if (display == 'under' || display == 'over') {
+            
+            bb = item.sprite.getBBox();
+            bb.width = bb.width || (radius * 2);
+            bb.height = bb.height || (radius * 2);
+            y = y + (display == 'over'? -bb.height : bb.height);
+            
+            bb = label.getBBox();
+            width = bb.width/2;
+            height = bb.height/2;
+            x = x - width < bbox.x ? bbox.x + width : x;
+            x = (x + width > bbox.x + bbox.width) ? (x - (x + width - bbox.x - bbox.width)) : x;
+            y = y - height < bbox.y? bbox.y + height : y;
+            y = (y + height > bbox.y + bbox.height) ? (y - (y + height - bbox.y - bbox.height)) : y;
+        }
+
+        if (!chart.animate) {
+            label.setAttributes({
+                x: x,
+                y: y
+            }, true);
+            label.show(true);
+        }
+        else {
+            if (resizing) {
+                anim = item.sprite.getActiveAnimation();
+                if (anim) {
+                    anim.on('afteranimate', function() {
+                        label.setAttributes({
+                            x: x,
+                            y: y
+                        }, true);
+                        label.show(true);
+                    });
+                }
+                else {
+                    label.show(true);
+                }
+            }
+            else {
+                me.onAnimate(label, {
+                    to: {
+                        x: x,
+                        y: y
+                    }
+                });
+            }
+        }
+    },
+
+    
+    onPlaceCallout: function(callout, storeItem, item, i, display, animate, index) {
+        var me = this,
+            chart = me.chart,
+            surface = chart.surface,
+            resizing = chart.resizing,
+            config = me.callouts,
+            items = me.items,
+            cur = item.point,
+            normal,
+            bbox = callout.label.getBBox(),
+            offsetFromViz = 30,
+            offsetToSide = 10,
+            offsetBox = 3,
+            boxx, boxy, boxw, boxh,
+            p, clipRect = me.bbox,
+            x, y;
+
+        
+        normal = [Math.cos(Math.PI /4), -Math.sin(Math.PI /4)];
+        x = cur[0] + normal[0] * offsetFromViz;
+        y = cur[1] + normal[1] * offsetFromViz;
+
+        
+        boxx = x + (normal[0] > 0? 0 : -(bbox.width + 2 * offsetBox));
+        boxy = y - bbox.height /2 - offsetBox;
+        boxw = bbox.width + 2 * offsetBox;
+        boxh = bbox.height + 2 * offsetBox;
+
+        
+        
+        if (boxx < clipRect[0] || (boxx + boxw) > (clipRect[0] + clipRect[2])) {
+            normal[0] *= -1;
+        }
+        if (boxy < clipRect[1] || (boxy + boxh) > (clipRect[1] + clipRect[3])) {
+            normal[1] *= -1;
+        }
+
+        
+        x = cur[0] + normal[0] * offsetFromViz;
+        y = cur[1] + normal[1] * offsetFromViz;
+
+        
+        boxx = x + (normal[0] > 0? 0 : -(bbox.width + 2 * offsetBox));
+        boxy = y - bbox.height /2 - offsetBox;
+        boxw = bbox.width + 2 * offsetBox;
+        boxh = bbox.height + 2 * offsetBox;
+
+        if (chart.animate) {
+            
+            me.onAnimate(callout.lines, {
+                to: {
+                    path: ["M", cur[0], cur[1], "L", x, y, "Z"]
+                }
+            }, true);
+            
+            me.onAnimate(callout.box, {
+                to: {
+                    x: boxx,
+                    y: boxy,
+                    width: boxw,
+                    height: boxh
+                }
+            }, true);
+            
+            me.onAnimate(callout.label, {
+                to: {
+                    x: x + (normal[0] > 0? offsetBox : -(bbox.width + offsetBox)),
+                    y: y
+                }
+            }, true);
+        } else {
+            
+            callout.lines.setAttributes({
+                path: ["M", cur[0], cur[1], "L", x, y, "Z"]
+            }, true);
+            
+            callout.box.setAttributes({
+                x: boxx,
+                y: boxy,
+                width: boxw,
+                height: boxh
+            }, true);
+            
+            callout.label.setAttributes({
+                x: x + (normal[0] > 0? offsetBox : -(bbox.width + offsetBox)),
+                y: y
+            }, true);
+        }
+        for (p in callout) {
+            callout[p].show(true);
+        }
+    },
+
+    
+    onAnimate: function(sprite, attr) {
+        sprite.show();
+        return this.callParent(arguments);
+    },
+
+    isItemInPoint: function(x, y, item) {
+        var point,
+            tolerance = 10,
+            abs = Math.abs;
+
+        function dist(point) {
+            var dx = abs(point[0] - x),
+                dy = abs(point[1] - y);
+            return Math.sqrt(dx * dx + dy * dy);
+        }
+        point = item.point;
+        return (point[0] - tolerance <= x && point[0] + tolerance >= x &&
+            point[1] - tolerance <= y && point[1] + tolerance >= y);
+    }
+});
+
+
+
+Ext.define('Ext.layout.container.Table', {
+
+    
+
+    alias: ['layout.table'],
+    extend: 'Ext.layout.container.Container',
+    alternateClassName: 'Ext.layout.TableLayout',
+
+    
+
+    
+
+    
+    monitorResize:false,
+
+    type: 'table',
+
+    clearEl: true, 
+
+    targetCls: Ext.baseCSSPrefix + 'table-layout-ct',
+    tableCls: Ext.baseCSSPrefix + 'table-layout',
+    cellCls: Ext.baseCSSPrefix + 'table-layout-cell',
+
+    
+    tableAttrs: null,
+
+    
+
+    
+
+    itemSizePolicy: {
+        setsWidth: 0,
+        setsHeight: 0
+    },
+
+    getItemSizePolicy: function (item) {
+        return this.itemSizePolicy;
+    },
+
+    getLayoutItems: function() {
+        var me = this,
+            result = [],
+            items = me.callParent(),
+            item,
+            len = items.length, i;
+
+        for (i = 0; i < len; i++) {
+            item = items[i];
+            if (!item.hidden) {
+                result.push(item);
+            }
+        }
+        return result;
+    },
+
+    
+    renderChildren: function() {
+        var me = this,
+            items = me.getLayoutItems(),
+            tbody = me.owner.getTargetEl().child('table', true).tBodies[0],
+            rows = tbody.rows,
+            i = 0,
+            len = items.length,
+            cells, curCell, rowIdx, cellIdx, item, trEl, tdEl, itemCt;
+
+        
+        cells = me.calculateCells(items);
+
+        
+        
+        
+        for (; i < len; i++) {
+            curCell = cells[i];
+            rowIdx = curCell.rowIdx;
+            cellIdx = curCell.cellIdx;
+            item = items[i];
+
+            
+            trEl = rows[rowIdx];
+            if (!trEl) {
+                trEl = tbody.insertRow(rowIdx);
+                if (me.trAttrs) {
+                    trEl.set(me.trAttrs);
+                }
+            }
+
+            
+            itemCt = tdEl = Ext.get(trEl.cells[cellIdx] || trEl.insertCell(cellIdx));
+            if (me.needsDivWrap()) { 
+                itemCt = tdEl.first() || tdEl.createChild({tag: 'div'});
+                itemCt.setWidth(null);
+            }
+
+            
+            if (!item.rendered) {
+                me.renderItem(item, itemCt, 0);
+            }
+            else if (!me.isValidParent(item, itemCt, rowIdx, cellIdx, tbody)) {
+                me.moveItem(item, itemCt, 0);
+            }
+
+            
+            if (me.tdAttrs) {
+                tdEl.set(me.tdAttrs);
+            }
+            if (item.tdAttrs) {
+                tdEl.set(item.tdAttrs);
+            }
+            tdEl.set({
+                colSpan: item.colspan || 1,
+                rowSpan: item.rowspan || 1,
+                id: item.cellId || '',
+                cls: me.cellCls + ' ' + (item.cellCls || '')
+            });
+
+            
+            if (!cells[i + 1] || cells[i + 1].rowIdx !== rowIdx) {
+                cellIdx++;
+                while (trEl.cells[cellIdx]) {
+                    trEl.deleteCell(cellIdx);
+                }
+            }
+        }
+
+        
+        rowIdx++;
+        while (tbody.rows[rowIdx]) {
+            tbody.deleteRow(rowIdx);
+        }
+    },
+
+    calculate: function (ownerContext) {
+        if (!ownerContext.hasDomProp('containerChildrenDone')) {
+            this.done = false;
+        } else {
+            var targetContext = ownerContext.targetContext,
+                widthShrinkWrap = ownerContext.widthModel.shrinkWrap,
+                heightShrinkWrap = ownerContext.heightModel.shrinkWrap,
+                shrinkWrap = heightShrinkWrap || widthShrinkWrap,
+                table = shrinkWrap && targetContext.el.child('table', true),
+                targetPadding = shrinkWrap && targetContext.getPaddingInfo();
+
+            if (widthShrinkWrap) {
+                ownerContext.setContentWidth(table.offsetWidth + targetPadding.width, true);
+            }
+
+            if (heightShrinkWrap) {
+                ownerContext.setContentHeight(table.offsetHeight + targetPadding.height, true);
+            }
+        }
+    },
+
+    finalizeLayout: function() {
+        if (this.needsDivWrap()) {
+            
+            var items = this.getLayoutItems(),
+                i,
+                iLen  = items.length,
+                item;
+
+            for (i = 0; i < iLen; i++) {
+                item = items[i];
+
+                Ext.fly(item.el.dom.parentNode).setWidth(item.getWidth());
+            }
+        }
+        if (Ext.isIE6 || (Ext.isIEQuirks)) {
+            
+            this.owner.getTargetEl().child('table').repaint();
+        }
+    },
+
+    
+    calculateCells: function(items) {
+        var cells = [],
+            rowIdx = 0,
+            colIdx = 0,
+            cellIdx = 0,
+            totalCols = this.columns || Infinity,
+            rowspans = [], 
+            i = 0, j,
+            len = items.length,
+            item;
+
+        for (; i < len; i++) {
+            item = items[i];
+
+            
+            while (colIdx >= totalCols || rowspans[colIdx] > 0) {
+                if (colIdx >= totalCols) {
+                    
+                    colIdx = 0;
+                    cellIdx = 0;
+                    rowIdx++;
+
+                    
+                    for (j = 0; j < totalCols; j++) {
+                        if (rowspans[j] > 0) {
+                            rowspans[j]--;
+                        }
+                    }
+                } else {
+                    colIdx++;
+                }
+            }
+
+            
+            cells.push({
+                rowIdx: rowIdx,
+                cellIdx: cellIdx
+            });
+
+            
+            for (j = item.colspan || 1; j; --j) {
+                rowspans[colIdx] = item.rowspan || 1;
+                ++colIdx;
+            }
+            ++cellIdx;
+        }
+
+        return cells;
+    },
+
+    getRenderTree: function() {
+        var me = this,
+            items = me.getLayoutItems(),
+            cells,
+            rows = [],
+            result = Ext.apply({
+                tag: 'table',
+                role: 'presentation',
+                cls: me.tableCls,
+                cellspacing: 0,
+                cn: {
+                    tag: 'tbody',
+                    cn: rows
+                }
+            }, me.tableAttrs),
+            tdAttrs = me.tdAttrs,
+            needsDivWrap = me.needsDivWrap(),
+            i, len = items.length, item, curCell, tr, rowIdx, cellIdx, cell;
+
+        
+        cells = me.calculateCells(items);
+
+        for (i = 0; i < len; i++) {
+            item = items[i];
+            
+            curCell = cells[i];
+            rowIdx = curCell.rowIdx;
+            cellIdx = curCell.cellIdx;
+
+            
+            tr = rows[rowIdx];
+            if (!tr) {
+                tr = rows[rowIdx] = {
+                    tag: 'tr',
+                    cn: []
+                };
+                if (me.trAttrs) {
+                    Ext.apply(tr, me.trAttrs);
+                }
+            }
+
+            
+            cell = tr.cn[cellIdx] = {
+                tag: 'td'
+            };
+            if (tdAttrs) {
+                Ext.apply(cell, tdAttrs);
+            }
+            Ext.apply(cell, {
+                colSpan: item.colspan || 1,
+                rowSpan: item.rowspan || 1,
+                id: item.cellId || '',
+                cls: me.cellCls + ' ' + (item.cellCls || '')
+            });
+
+            if (needsDivWrap) { 
+                cell = cell.cn = {
+                    tag: 'div'
+                };
+            }
+
+            me.configureItem(item);
+            
+            cell.cn = item.getRenderTree();
+        }
+        return result;
+    },
+
+    isValidParent: function(item, target, rowIdx, cellIdx) {
+        var tbody,
+            correctCell,
+            table;
+
+        
+        if (arguments.length === 3) {
+            table = item.el.up('table');
+            return table && table.dom.parentNode === target.dom;
+        }
+        tbody = this.owner.getTargetEl().child('table', true).tBodies[0];
+        correctCell = tbody.rows[rowIdx].cells[cellIdx];
+        return item.el.dom.parentNode === correctCell;
+    },
+
+    
+    needsDivWrap: function() {
+        return Ext.isOpera10_5;
+    }
+});
+
+
+Ext.define('Ext.container.ButtonGroup', {
+    extend: 'Ext.panel.Panel',
+    alias: 'widget.buttongroup',
+    alternateClassName: 'Ext.ButtonGroup',
+
+    requires: ['Ext.layout.container.Table'],
+
+    
+
+    
+    baseCls: Ext.baseCSSPrefix + 'btn-group',
+
+    
+    layout: {
+        type: 'table'
+    },
+
+    defaultType: 'button',
+
+    
+    frame: true,
+
+    frameHeader: false,
+
+    titleAlign: 'center',
+
+    initComponent : function() {
+        
+        var me = this,
+            cols = me.columns;
+
+        me.noTitleCls = me.baseCls + '-notitle';
+        if (cols) {
+            me.layout = Ext.apply({}, {columns: cols}, me.layout);
+        }
+
+        if (!me.title) {
+            me.addCls(me.noTitleCls);
+        }
+        me.callParent(arguments);
+    },
+
+    
+    onBeforeAdd: function(component) {
+        if (component.isButton) {
+            component.ui = component.ui + '-toolbar';
+        }
+        this.callParent(arguments);
+    },
+
+    
+    applyDefaults: function(c) {
+        if (!Ext.isString(c)) {
+            c = this.callParent(arguments);
+        }
+        return c;
+    }
+
+    
+    
+    
+    
+    
+});
+
+
+Ext.define('Ext.container.Viewport', {
+    extend: 'Ext.container.Container',
+    alias: 'widget.viewport',
+    requires: ['Ext.EventManager'],
+    alternateClassName: 'Ext.Viewport',
+
+    
+    
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+    isViewport: true,
+
+    ariaRole: 'application',
+    
+    preserveElOnDestroy: true,
+
+    initComponent : function() {
+        var me = this,
+            html = document.body.parentNode,
+            el;
+
+        
+        Ext.getScrollbarSize();
+        
+        
+        me.width = me.height = undefined;
+
+        me.callParent(arguments);
+        Ext.fly(html).addCls(Ext.baseCSSPrefix + 'viewport');
+        if (me.autoScroll) {
+            delete me.autoScroll;
+            Ext.fly(html).setStyle('overflow', 'auto');
+        }
+        me.el = el = Ext.getBody();
+        el.setHeight = Ext.emptyFn;
+        el.setWidth = Ext.emptyFn;
+        el.setSize = Ext.emptyFn;
+        el.dom.scroll = 'no';
+        me.allowDomMove = false;
+        me.renderTo = me.el;
+    },
+    
+    onRender: function() {
+        var me = this;
+
+        me.callParent(arguments);
+
+        
+        
+        me.width = Ext.Element.getViewportWidth();
+        me.height = Ext.Element.getViewportHeight();
+    },
+
+    afterFirstLayout: function() {
+        var me = this;
+
+        me.callParent(arguments);
+        setTimeout(function() {
+            Ext.EventManager.onWindowResize(me.fireResize, me);
+        }, 1);
+    },
+
+    fireResize : function(width, height){
+        
+        
+        if (width != this.width || height != this.height) {
+            this.setSize(width, height);
+        }
+    }
+});
+
+
+Ext.define('Ext.data.proxy.Proxy', {
+    alias: 'proxy.proxy',
+    alternateClassName: ['Ext.data.DataProxy', 'Ext.data.Proxy'],
+
+    uses: [
+        'Ext.data.Batch',
+        'Ext.data.Operation',
+        'Ext.data.Model'
+    ],
+
+    mixins: {
+        observable: 'Ext.util.Observable'
+    },
+
+    
+    batchOrder: 'create,update,destroy',
+
+    
+    batchActions: true,
+
+    
+    defaultReaderType: 'json',
+
+    
+    defaultWriterType: 'json',
+
+    
+
+    
+
+    
+
+    
+    isProxy: true,
+
+    
+    constructor: function(config) {
+        config = config || {};
+
+        if (config.model === undefined) {
+            delete config.model;
+        }
+
+        this.mixins.observable.constructor.call(this, config);
+
+        if (this.model !== undefined && !(this.model instanceof Ext.data.Model)) {
+            this.setModel(this.model);
+        }
+
+        
+    },
+
+    
+    setModel: function(model, setOnStore) {
+        this.model = Ext.ModelManager.getModel(model);
+
+        var reader = this.reader,
+            writer = this.writer;
+
+        this.setReader(reader);
+        this.setWriter(writer);
+
+        if (setOnStore && this.store) {
+            this.store.setModel(this.model);
+        }
+    },
+
+    
+    getModel: function() {
+        return this.model;
+    },
+
+    
+    setReader: function(reader) {
+        var me = this,
+            needsCopy = true;
+
+        if (reader === undefined || typeof reader == 'string') {
+            reader = {
+                type: reader
+            };
+            needsCopy = false;
+        }
+
+        if (reader.isReader) {
+            reader.setModel(me.model);
+        } else {
+            if (needsCopy) {
+                reader = Ext.apply({}, reader);
+            }
+            Ext.applyIf(reader, {
+                proxy: me,
+                model: me.model,
+                type : me.defaultReaderType
+            });
+
+            reader = Ext.createByAlias('reader.' + reader.type, reader);
+        }
+
+        if (reader.onMetaChange) {
+            reader.onMetaChange = Ext.Function.createSequence(reader.onMetaChange, this.onMetaChange, this);
+        }
+
+        me.reader = reader;
+        return me.reader;
+    },
+
+    
+    getReader: function() {
+        return this.reader;
+    },
+
+    
+    onMetaChange: function(meta) {
+        this.fireEvent('metachange', this, meta);
+    },
+
+    
+    setWriter: function(writer) {
+        var me = this,
+            needsCopy = true;
+            
+        if (writer === undefined || typeof writer == 'string') {
+            writer = {
+                type: writer
+            };
+            needsCopy = false;
+        }
+
+        if (!writer.isWriter) {
+            if (needsCopy) {
+                writer = Ext.apply({}, writer);
+            }
+            Ext.applyIf(writer, {
+                model: me.model,
+                type : me.defaultWriterType
+            });
+
+            writer = Ext.createByAlias('writer.' + writer.type, writer);
+        }
+
+        me.writer = writer;
+
+        return me.writer;
+    },
+
+    
+    getWriter: function() {
+        return this.writer;
+    },
+
+    
+    create: Ext.emptyFn,
+
+    
+    read: Ext.emptyFn,
+
+    
+    update: Ext.emptyFn,
+
+    
+    destroy: Ext.emptyFn,
+
+    
+    batch: function(options, listeners) {
+        var me = this,
+            useBatch = me.batchActions,
+            batch,
+            records,
+            actions, aLen, action, a, r, rLen, record;
+
+        if (options.operations === undefined) {
+            
+            
+            options = {
+                operations: options,
+                listeners: listeners
+            };
+        }
+
+        if (options.batch) {
+            if (Ext.isDefined(options.batch.runOperation)) {
+                batch = Ext.applyIf(options.batch, {
+                    proxy: me,
+                    listeners: {}
+                });
+            }
+        } else {
+            options.batch = {
+                proxy: me,
+                listeners: options.listeners || {}
+            };
+        }
+
+        if (!batch) {
+            batch = new Ext.data.Batch(options.batch);
+        }
+
+        batch.on('complete', Ext.bind(me.onBatchComplete, me, [options], 0));
+
+        actions = me.batchOrder.split(',');
+        aLen    = actions.length;
+
+        for (a = 0; a < aLen; a++) {
+            action  = actions[a];
+            records = options.operations[action];
+
+            if (records) {
+                if (useBatch) {
+                    batch.add(new Ext.data.Operation({
+                        action  : action,
+                        records : records
+                    }));
+                } else {
+                    rLen = records.length;
+
+                    for (r = 0; r < rLen; r++) {
+                        record = records[r];
+
+                        batch.add(new Ext.data.Operation({
+                            action  : action,
+                            records : [record]
+                        }));
+                    }
+                }
+            }
+        }
+
+        batch.start();
+        return batch;
+    },
+
+    
+    onBatchComplete: function(batchOptions, batch) {
+        var scope = batchOptions.scope || this;
+
+        if (batch.hasException) {
+            if (Ext.isFunction(batchOptions.failure)) {
+                Ext.callback(batchOptions.failure, scope, [batch, batchOptions]);
+            }
+        } else if (Ext.isFunction(batchOptions.success)) {
+            Ext.callback(batchOptions.success, scope, [batch, batchOptions]);
+        }
+
+        if (Ext.isFunction(batchOptions.callback)) {
+            Ext.callback(batchOptions.callback, scope, [batch, batchOptions]);
+        }
+    }
+}, function() {
+    
+    Ext.data.DataProxy = this;
+});
+
+
+Ext.define('Ext.data.AbstractStore', {
+	requires: [
+        'Ext.util.MixedCollection',
+        'Ext.data.proxy.Proxy',
+        'Ext.data.Operation',
+        'Ext.util.Filter'
+    ],
+
+    mixins: {
+        observable: 'Ext.util.Observable',
+        sortable: 'Ext.util.Sortable'
+    },
+
+    statics: {
+        
+        create: function(store) {
+            if (!store.isStore) {
+                if (!store.type) {
+                    store.type = 'store';
+                }
+                store = Ext.createByAlias('store.' + store.type, store);
+            }
+            return store;
+        }
+    },
+
+    
+    remoteSort  : false,
+
+    
+    remoteFilter: false,
+
+    
+
+    
+    autoLoad: undefined,
+
+    
+    autoSync: false,
+
+    
+    batchUpdateMode: 'operation',
+
+    
+    filterOnLoad: true,
+
+    
+    sortOnLoad: true,
+
+    
+    implicitModel: false,
+
+    
+    defaultProxyType: 'memory',
+
+    
+    isDestroyed: false,
+
+    
+    isStore: true,
+
+    
+
+    
+
+    
+
+    
+
+    sortRoot: 'data',
+
+    
+    constructor: function(config) {
+        var me = this,
+            filters;
+
+        
+
+        
+
+        
+
+        
+        
+        
+
+        
+
+        
+
+        
+
+        
+        
+        
+
+        Ext.apply(me, config);
+        
+
+        
+        me.removed = [];
+
+        me.mixins.observable.constructor.apply(me, arguments);
+
+
+        me.model = Ext.ModelManager.getModel(me.model);
+
+        
+        Ext.applyIf(me, {
+            modelDefaults: {}
+        });
+
+        
+        if (!me.model && me.fields) {
+            me.model = Ext.define('Ext.data.Store.ImplicitModel-' + (me.storeId || Ext.id()), {
+                extend: 'Ext.data.Model',
+                fields: me.fields,
+                proxy: me.proxy || me.defaultProxyType
+            });
+
+            delete me.fields;
+
+            me.implicitModel = true;
+        }
+
+
+        
+        me.setProxy(me.proxy || me.model.getProxy());
+
+        me.proxy.on('metachange', me.onMetaChange, me);
+
+        if (me.id && !me.storeId) {
+            me.storeId = me.id;
+            delete me.id;
+        }
+
+        if (me.storeId) {
+            Ext.data.StoreManager.register(me);
+        }
+
+        me.mixins.sortable.initSortable.call(me);
+
+        
+        filters = me.decodeFilters(me.filters);
+        me.filters = new Ext.util.MixedCollection();
+        me.filters.addAll(filters);
+    },
+
+    
+    setProxy: function(proxy) {
+        var me = this;
+
+        if (proxy instanceof Ext.data.proxy.Proxy) {
+            proxy.setModel(me.model);
+        } else {
+            if (Ext.isString(proxy)) {
+                proxy = {
+                    type: proxy
+                };
+            }
+            Ext.applyIf(proxy, {
+                model: me.model
+            });
+
+            proxy = Ext.createByAlias('proxy.' + proxy.type, proxy);
+        }
+
+        me.proxy = proxy;
+
+        return me.proxy;
+    },
+
+    
+    getProxy: function() {
+        return this.proxy;
+    },
+
+    
+    onMetaChange: function(proxy, meta) {
+        this.fireEvent('metachange', this, meta);
+    },
+
+    
+    create: function(data, options) {
+        var me = this,
+            instance = Ext.ModelManager.create(Ext.applyIf(data, me.modelDefaults), me.model.modelName),
+            operation;
+
+        options = options || {};
+
+        Ext.applyIf(options, {
+            action : 'create',
+            records: [instance]
+        });
+
+        operation = new Ext.data.Operation(options);
+
+        me.proxy.create(operation, me.onProxyWrite, me);
+
+        return instance;
+    },
+
+    read: function() {
+        return this.load.apply(this, arguments);
+    },
+
+    update: function(options) {
+        var me = this,
+            operation;
+        options = options || {};
+
+        Ext.applyIf(options, {
+            action : 'update',
+            records: me.getUpdatedRecords()
+        });
+
+        operation = new Ext.data.Operation(options);
+
+        return me.proxy.update(operation, me.onProxyWrite, me);
+    },
+
+    
+    onProxyWrite: function(operation) {
+        var me = this,
+            success = operation.wasSuccessful(),
+            records = operation.getRecords();
+
+        switch (operation.action) {
+            case 'create':
+                me.onCreateRecords(records, operation, success);
+                break;
+            case 'update':
+                me.onUpdateRecords(records, operation, success);
+                break;
+            case 'destroy':
+                me.onDestroyRecords(records, operation, success);
+                break;
+        }
+
+        if (success) {
+            me.fireEvent('write', me, operation);
+            me.fireEvent('datachanged', me);
+            me.fireEvent('refresh', me);
+        }
+        
+        Ext.callback(operation.callback, operation.scope || me, [records, operation, success]);
+    },
+    
+    
+    onCreateRecords: Ext.emptyFn,
+    
+    
+    onUpdateRecords: Ext.emptyFn,
+    
+    
+    onDestroyRecords: function(records, operation, success) {
+        if (success) {
+            this.removed = [];
+        }
+    },
+
+    
+    destroy: function(options) {
+        var me = this,
+            operation;
+
+        options = options || {};
+
+        Ext.applyIf(options, {
+            action : 'destroy',
+            records: me.getRemovedRecords()
+        });
+
+        operation = new Ext.data.Operation(options);
+
+        return me.proxy.destroy(operation, me.onProxyWrite, me);
+    },
+
+    
+    onBatchOperationComplete: function(batch, operation) {
+        return this.onProxyWrite(operation);
+    },
+
+    
+    onBatchComplete: function(batch, operation) {
+        var me = this,
+            operations = batch.operations,
+            length = operations.length,
+            i;
+
+        me.suspendEvents();
+
+        for (i = 0; i < length; i++) {
+            me.onProxyWrite(operations[i]);
+        }
+
+        me.resumeEvents();
+
+        me.fireEvent('datachanged', me);
+        me.fireEvent('refresh', me);
+    },
+
+    
+    onBatchException: function(batch, operation) {
+        
+        
+        
+        
+        
+    },
+
+    
+    filterNew: function(item) {
+        
+        return item.phantom === true && item.isValid();
+    },
+
+    
+    getNewRecords: function() {
+        return [];
+    },
+
+    
+    getUpdatedRecords: function() {
+        return [];
+    },
+
+    
+    getModifiedRecords : function(){
+        return [].concat(this.getNewRecords(), this.getUpdatedRecords());
+    },
+    
+    
+    filterUpdated: function(item) {
+        
+        return item.dirty === true && item.phantom !== true && item.isValid();
+    },
+
+    
+    getRemovedRecords: function() {
+        return this.removed;
+    },
+
+    filter: function(filters, value) {
+
+    },
+
+    
+    decodeFilters: function(filters) {
+        if (!Ext.isArray(filters)) {
+            if (filters === undefined) {
+                filters = [];
+            } else {
+                filters = [filters];
+            }
+        }
+
+        var length = filters.length,
+            Filter = Ext.util.Filter,
+            config, i;
+
+        for (i = 0; i < length; i++) {
+            config = filters[i];
+
+            if (!(config instanceof Filter)) {
+                Ext.apply(config, {
+                    root: 'data'
+                });
+
+                
+                if (config.fn) {
+                    config.filterFn = config.fn;
+                }
+
+                
+                if (typeof config == 'function') {
+                    config = {
+                        filterFn: config
+                    };
+                }
+
+                filters[i] = new Filter(config);
+            }
+        }
+
+        return filters;
+    },
+
+    clearFilter: function(supressEvent) {
+
+    },
+
+    isFiltered: function() {
+
+    },
+
+    filterBy: function(fn, scope) {
+
+    },
+
+    
+    sync: function(options) {
+        var me = this,
+            operations = {},
+            toCreate = me.getNewRecords(),
+            toUpdate = me.getUpdatedRecords(),
+            toDestroy = me.getRemovedRecords(),
+            needsSync = false;
+
+        if (toCreate.length > 0) {
+            operations.create = toCreate;
+            needsSync = true;
+        }
+
+        if (toUpdate.length > 0) {
+            operations.update = toUpdate;
+            needsSync = true;
+        }
+
+        if (toDestroy.length > 0) {
+            operations.destroy = toDestroy;
+            needsSync = true;
+        }
+
+        if (needsSync && me.fireEvent('beforesync', operations) !== false) {
+            options = options || {};
+
+            me.proxy.batch(Ext.apply(options, {
+                operations: operations,
+                listeners: me.getBatchListeners()
+            }));
+        }
+        
+        return me;
+    },
+    
+    
+    getBatchListeners: function() {
+        var me = this,
+            listeners = {
+                scope: me,
+                exception: me.onBatchException
+            };
+
+        if (me.batchUpdateMode == 'operation') {
+            listeners.operationcomplete = me.onBatchOperationComplete;
+        } else {
+            listeners.complete = me.onBatchComplete;
+        }
+
+        return listeners;
+    },
+
+    
+    save: function() {
+        return this.sync.apply(this, arguments);
+    },
+
+    
+    load: function(options) {
+        var me = this,
+            operation;
+
+        options = Ext.apply({
+            action: 'read',
+            filters: me.filters.items,
+            sorters: me.getSorters()
+        }, options);
+        me.lastOptions = options;
+
+        operation = new Ext.data.Operation(options);
+
+        if (me.fireEvent('beforeload', me, operation) !== false) {
+            me.loading = true;
+            me.proxy.read(operation, me.onProxyLoad, me);
+        }
+
+        return me;
+    },
+
+    
+    reload: function(options) {
+        return this.load(Ext.apply(this.lastOptions, options));
+    },
+
+    
+    afterEdit : function(record, modifiedFieldNames) {
+        var me = this,
+            i, shouldSync;
+
+        if (me.autoSync && !me.autoSyncSuspended) {
+            for (i = modifiedFieldNames.length; i--;) {
+                
+                if (record.fields.get(modifiedFieldNames[i]).persist) {
+                    shouldSync = true;
+                    break;
+                }
+            }
+            if (shouldSync) {
+                me.sync();
+            }
+        }
+
+        me.fireEvent('update', me, record, Ext.data.Model.EDIT, modifiedFieldNames);
+    },
+
+    
+    afterReject : function(record) {
+        
+        
+        
+        
+        
+        this.fireEvent('update', this, record, Ext.data.Model.REJECT, null);
+    },
+
+    
+    afterCommit : function(record) {
+        
+        
+        
+        
+        
+        this.fireEvent('update', this, record, Ext.data.Model.COMMIT, null);
+    },
+
+    
+    destroyStore: function() {
+        var me = this;
+
+        if (!me.isDestroyed) {
+            if (me.storeId) {
+                Ext.data.StoreManager.unregister(me);
+            }
+            me.clearData();
+            me.data = me.tree = me.sorters = me.filters = me.groupers = null;
+            if (me.reader) {
+                me.reader.destroyReader();
+            }
+            me.proxy = me.reader = me.writer = null;
+            me.clearListeners();
+            me.isDestroyed = true;
+
+            if (me.implicitModel) {
+                Ext.destroy(me.model);
+            } else {
+                me.model = null;
+            }
+        }
+    },
+
+    
+    doSort: function(sorterFn) {
+        var me = this;
+        if (me.remoteSort) {
+            
+            me.load();
+        } else {
+            me.data.sortBy(sorterFn);
+            me.fireEvent('datachanged', me);
+            me.fireEvent('refresh', me);
+        }
+    },
+
+    
+    clearData: Ext.emptyFn,
+    
+    
+    getCount: Ext.emptyFn,
+
+    
+    getById: Ext.emptyFn,
+
+    
+    removeAll: Ext.emptyFn,
+    
+    
+
+    
+    isLoading: function() {
+        return !!this.loading;
+    },
+
+    
+    suspendAutoSync: function() {
+        this.autoSyncSuspended = true;
+    },
+
+    
+    resumeAutoSync: function() {
+        this.autoSyncSuspended = false;
+    }
+
+});
+
+
+Ext.define('Ext.data.ResultSet', {
+    
+    loaded: true,
+
+    
+    count: 0,
+
+    
+    total: 0,
+
+    
+    success: false,
+
+    
+
+    
+    constructor: function(config) {
+        Ext.apply(this, config);
+
+        
+        this.totalRecords = this.total;
+
+        if (config.count === undefined) {
+            this.count = this.records.length;
+        }
+    }
+});
+
+
+Ext.define('Ext.data.reader.Reader', {
+    requires: ['Ext.data.ResultSet', 'Ext.XTemplate'],
+    alternateClassName: ['Ext.data.Reader', 'Ext.data.DataReader'],
+
+    mixins: {
+        observable: 'Ext.util.Observable'
+    },
+
+    
+
+    
+    totalProperty: 'total',
+
+    
+    successProperty: 'success',
+
+    
+    root: '',
+    
+    
+    
+    
+    implicitIncludes: true,
+    
+    
+    readRecordsOnFailure: true,
+    
+    
+    
+    
+    isReader: true,
+
+    
+    
+    
+    applyDefaults: true,
+
+    lastFieldGeneration: null,
+    
+    
+    constructor: function(config) {
+        var me = this;
+        
+        me.mixins.observable.constructor.call(me, config);
+        me.fieldCount = 0;
+        me.model = Ext.ModelManager.getModel(me.model);
+        me.accessExpressionFn = Ext.Function.bind(me.createFieldAccessExpression, me);
+
+        
+        
+        
+        
+        
+        if (me.model && me.model.prototype.fields) {
+            me.buildExtractors();
+        }
+
+        this.addEvents(
+            
+            'exception'
+        );
+    },
+
+    
+    setModel: function(model, setOnProxy) {
+        var me = this;
+        
+        me.model = Ext.ModelManager.getModel(model);
+        me.buildExtractors(true);
+        
+        if (setOnProxy && me.proxy) {
+            me.proxy.setModel(me.model, true);
+        }
+    },
+
+    
+    read: function(response) {
+        var data;
+
+        if (response) {
+            data = response.responseText ? this.getResponseData(response) : this.readRecords(response);
+        }
+
+        return data || this.nullResultSet;
+    },
+
+    
+    readRecords: function(data) {
+        var me = this,
+            success,
+            recordCount,
+            records,
+            root,
+            total,
+            value,
+            message;
+        
+        
+        if (me.lastFieldGeneration !== me.model.prototype.fields.generation) {
+            me.buildExtractors(true);
+        }
+        
+        
+        me.rawData = data;
+
+        data = me.getData(data);
+        
+        success = true;
+        recordCount = 0;
+        records = [];
+            
+        if (me.successProperty) {
+            value = me.getSuccess(data);
+            if (value === false || value === 'false') {
+                success = false;
+            }
+        }
+        
+        if (me.messageProperty) {
+            message = me.getMessage(data);
+        }
+
+        
+        
+        if (me.readRecordsOnFailure || success) {
+            
+            
+            root = Ext.isArray(data) ? data : me.getRoot(data);
+            
+            if (root) {
+                total = root.length;
+            }
+
+          if (me.totalProperty) {
+                value = parseInt(me.getTotal(data), 10);
+                if (!isNaN(value)) {
+                    total = value;
+                }
+            }
+
+           if (root) {
+                records = me.extractData(root);
+                recordCount = records.length;
+            }
+        }
+
+        return new Ext.data.ResultSet({
+            total  : total || recordCount,
+            count  : recordCount,
+            records: records,
+            success: success,
+            message: message
+        });
+    },
+
+    
+    extractData : function(root) {
+        var me = this,
+            records = [],
+            Model   = me.model,
+            length  = root.length,
+            convertedValues, node, record, i;
+            
+        if (!root.length && Ext.isObject(root)) {
+            root = [root];
+            length = 1;
+        }
+
+        for (i = 0; i < length; i++) {
+            node = root[i];
+            if (!node.isModel) { 
+                
+                
+                record = new Model(undefined, me.getId(node), node, convertedValues = {});
+
+                
+                
+                record.phantom = false;
+
+                
+                me.convertRecordData(convertedValues, node, record);
+
+                records.push(record);
+                
+                if (me.implicitIncludes) {
+                    me.readAssociated(record, node);
+                }
+            } else {
+                
+                
+                records.push(node);
+            }
+        }
+
+        return records;
+    },
+    
+    
+    readAssociated: function(record, data) {
+        var associations = record.associations.items,
+            i            = 0,
+            length       = associations.length,
+            association, associationData, proxy, reader;
+        
+        for (; i < length; i++) {
+            association     = associations[i];
+            associationData = this.getAssociatedDataRoot(data, association.associationKey || association.name);
+            
+            if (associationData) {
+                reader = association.getReader();
+                if (!reader) {
+                    proxy = association.associatedModel.proxy;
+                    
+                    if (proxy) {
+                        reader = proxy.getReader();
+                    } else {
+                        reader = new this.constructor({
+                            model: association.associatedName
+                        });
+                    }
+                }
+                association.read(record, reader, associationData);
+            }  
+        }
+    },
+    
+    
+    getAssociatedDataRoot: function(data, associationName) {
+        return data[associationName];
+    },
+    
+    getFields: function() {
+        return this.model.prototype.fields.items;
+    },
+
+    
+    getData: function(data) {
+        return data;
+    },
+
+    
+    getRoot: function(data) {
+        return data;
+    },
+
+    
+    getResponseData: function(response) {
+    },
+
+    
+    onMetaChange : function(meta) {
+        var me = this,
+            fields = meta.fields || me.getFields(),
+            newModel,
+            clientIdProperty;
+        
+        
+        me.metaData = meta;
+        
+        
+        me.root = meta.root || me.root;
+        me.idProperty = meta.idProperty || me.idProperty;
+        me.totalProperty = meta.totalProperty || me.totalProperty;
+        me.successProperty = meta.successProperty || me.successProperty;
+        me.messageProperty = meta.messageProperty || me.messageProperty;
+        clientIdProperty = meta.clientIdProperty;
+
+        if (me.model) {
+            me.model.setFields(fields, me.idProperty, clientIdProperty);
+            me.setModel(me.model, true);
+        }
+        else {
+            newModel = Ext.define("Ext.data.reader.Json-Model" + Ext.id(), {
+                extend: 'Ext.data.Model',
+                fields: fields,
+                clientIdProperty: clientIdProperty
+            });
+            if (me.idProperty) {
+                
+                
+                
+                
+                newModel.idProperty = me.idProperty;
+            }
+            me.setModel(newModel, true);
+        }
+    },
+    
+    
+    getIdProperty: function(){
+        return this.idProperty || this.model.prototype.idProperty;
+    },
+
+    
+    buildExtractors: function(force) {
+        var me          = this,
+            idProp      = me.getIdProperty(),
+            totalProp   = me.totalProperty,
+            successProp = me.successProperty,
+            messageProp = me.messageProperty,
+            accessor,
+            idField,
+            map;
+            
+        if (force === true) {
+            delete me.convertRecordData;
+        }
+        
+        if (me.convertRecordData) {
+            return;
+        }   
+
+        
+        if (totalProp) {
+            me.getTotal = me.createAccessor(totalProp);
+        }
+
+        if (successProp) {
+            me.getSuccess = me.createAccessor(successProp);
+        }
+
+        if (messageProp) {
+            me.getMessage = me.createAccessor(messageProp);
+        }
+
+        if (idProp) {
+            idField = me.model.prototype.fields.get(idProp);
+            if (idField) {
+                map = idField.mapping;
+                idProp = (map !== undefined && map !== null) ? map : idProp;
+            }
+            accessor = me.createAccessor(idProp);
+
+            me.getId = function(record) {
+                var id = accessor.call(me, record);
+                return (id === undefined || id === '') ? null : id;
+            };
+        } else {
+            me.getId = function() {
+                return null;
+            };
+        }
+        me.convertRecordData = me.buildRecordDataExtractor();
+        me.lastFieldGeneration = me.model.prototype.fields.generation;
+    },
+
+    recordDataExtractorTemplate : [
+        'var me = this\n',
+        '    ,fields = me.model.prototype.fields\n',
+        '    ,value\n',
+        '    ,internalId\n',
+        '<tpl for="fields">',
+        '    ,__field{#} = fields.get("{name}")\n',
+        '</tpl>', ';\n',
+
+        'return function(dest, source, record) {\n',
+        '<tpl for="fields">',
+        
+        '    value = {[ this.createFieldAccessExpression(values, "__field" + xindex, "source") ]};\n',
+
+        
+            '<tpl if="hasCustomConvert">',
+        '    dest["{name}"] = value === undefined ? __field{#}.convert(__field{#}.defaultValue, record) : __field{#}.convert(value, record);\n',
+
+        
+            '<tpl elseif="defaultValue !== undefined">',
+        '    if (value === undefined) {\n',
+        '        if (me.applyDefaults) {\n',
+                '<tpl if="convert">',
+        '            dest["{name}"] = __field{#}.convert(__field{#}.defaultValue, record);\n',
+                '<tpl else>',
+        '            dest["{name}"] = __field{#}.defaultValue\n',
+                '</tpl>',
+        '        };\n',
+        '    } else {\n',
+                '<tpl if="convert">',
+        '        dest["{name}"] = __field{#}.convert(value, record);\n',
+                '<tpl else>',
+        '        dest["{name}"] = value;\n',
+                '</tpl>',
+        '    };',
+
+        
+            '<tpl else>',
+        '    if (value !== undefined) {\n',
+                '<tpl if="convert">',
+        '        dest["{name}"] = __field{#}.convert(value, record);\n',
+                '<tpl else>',
+        '        dest["{name}"] = value;\n',
+                '</tpl>',
+        '    }\n',
+            '</tpl>',
+
+        '</tpl>',
+
+        
+        
+        
+        '<tpl if="clientIdProp">',
+        '    if (record && (internalId = {[ this.createFieldAccessExpression(\{mapping: values.clientIdProp\}, null, "source") ]})) {\n',
+        '        record.{["internalId"]} = internalId;\n',
+        '    }\n',
+        '</tpl>',
+
+        '};'
+    ],
+
+    
+    buildRecordDataExtractor: function() {
+        var me = this,
+            modelProto = me.model.prototype,
+            templateData = {
+                clientIdProp: modelProto.clientIdProperty,
+                fields: modelProto.fields.items
+            };
+
+        me.recordDataExtractorTemplate.createFieldAccessExpression = me.accessExpressionFn;
+        
+        
+        
+        
+        return Ext.functionFactory(me.recordDataExtractorTemplate.apply(templateData)).call(me);
+    },
+
+    destroyReader: function() {
+        var me = this;
+        delete me.proxy;
+        delete me.model;
+        delete me.convertRecordData;
+        delete me.getId;
+        delete me.getTotal;
+        delete me.getSuccess;
+        delete me.getMessage;
+    }
+}, function() {
+    var proto = this.prototype;
+    Ext.apply(proto, {
+        
+        nullResultSet: new Ext.data.ResultSet({
+            total  : 0,
+            count  : 0,
+            records: [],
+            success: true
+        }),
+        recordDataExtractorTemplate: new Ext.XTemplate(proto.recordDataExtractorTemplate)
+    });
+});
+
+
+Ext.define('Ext.data.reader.Json', {
+    extend: 'Ext.data.reader.Reader',
+    alternateClassName: 'Ext.data.JsonReader',
+    alias : 'reader.json',
+
+    root: '',
+
+    
+
+    
+    useSimpleAccessors: false,
+
+    
+    readRecords: function(data) {
+        
+        if (data.metaData) {
+            this.onMetaChange(data.metaData);
+        }
+
+        
+        this.jsonData = data;
+        return this.callParent([data]);
+    },
+
+    
+    getResponseData: function(response) {
+        var data, error;
+ 
+        try {
+            data = Ext.decode(response.responseText);
+            return this.readRecords(data);
+        } catch (ex) {
+            error = new Ext.data.ResultSet({
+                total  : 0,
+                count  : 0,
+                records: [],
+                success: false,
+                message: ex.message
+            });
+
+            this.fireEvent('exception', this, response, error);
+
+            Ext.Logger.warn('Unable to parse the JSON returned by the server');
+
+            return error;
+        }
+    },
+
+    
+    buildExtractors : function() {
+        var me = this;
+
+        me.callParent(arguments);
+
+        if (me.root) {
+            me.getRoot = me.createAccessor(me.root);
+        } else {
+            me.getRoot = function(root) {
+                return root;
+            };
+        }
+    },
+
+    
+    extractData: function(root) {
+        var recordName = this.record,
+            data = [],
+            length, i;
+
+        if (recordName) {
+            length = root.length;
+            
+            if (!length && Ext.isObject(root)) {
+                length = 1;
+                root = [root];
+            }
+
+            for (i = 0; i < length; i++) {
+                data[i] = root[i][recordName];
+            }
+        } else {
+            data = root;
+        }
+        return this.callParent([data]);
+    },
+
+    
+    createAccessor: (function() {
+        var re = /[\[\.]/;
+
+        return function(expr) {
+            if (Ext.isEmpty(expr)) {
+                return Ext.emptyFn;
+            }
+            if (Ext.isFunction(expr)) {
+                return expr;
+            }
+            if (this.useSimpleAccessors !== true) {
+                var i = String(expr).search(re);
+                if (i >= 0) {
+                    return Ext.functionFactory('obj', 'return obj' + (i > 0 ? '.' : '') + expr);
+                }
+            }
+            return function(obj) {
+                return obj[expr];
+            };
+        };
+    }()),
+
+    
+    createFieldAccessExpression: (function() {
+        var re = /[\[\.]/;
+
+        return function(field, fieldVarName, dataName) {
+            var me     = this,
+                hasMap = (field.mapping !== null),
+                map    = hasMap ? field.mapping : field.name,
+                result,
+                operatorSearch;
+
+            if (typeof map === 'function') {
+                result = fieldVarName + '.mapping(' + dataName + ', this)';
+            } else if (this.useSimpleAccessors === true || ((operatorSearch = String(map).search(re)) < 0)) {
+                if (!hasMap || isNaN(map)) {
+                    
+                    map = '"' + map + '"';
+                }
+                result = dataName + "[" + map + "]";
+            } else {
+                result = dataName + (operatorSearch > 0 ? '.' : '') + map;
+            }
+            return result;
+        };
+    }())
+});
+
+
+Ext.define('Ext.data.writer.Writer', {
+    alias: 'writer.base',
+    alternateClassName: ['Ext.data.DataWriter', 'Ext.data.Writer'],
+    
+    
+    writeAllFields: true,
+    
+    
+    nameProperty: 'name',
+
+    
+    isWriter: true,
+
+    
+    constructor: function(config) {
+        Ext.apply(this, config);
+    },
+
+    
+    write: function(request) {
+        var operation = request.operation,
+            records   = operation.records || [],
+            len       = records.length,
+            i         = 0,
+            data      = [];
+
+        for (; i < len; i++) {
+            data.push(this.getRecordData(records[i], operation));
+        }
+        return this.writeRecords(request, data);
+    },
+
+    
+    getRecordData: function(record, operation) {
+        var isPhantom = record.phantom === true,
+            writeAll = this.writeAllFields || isPhantom,
+            nameProperty = this.nameProperty,
+            fields = record.fields,
+            fieldItems = fields.items,
+            data = {},
+            clientIdProperty = record.clientIdProperty,
+            changes,
+            name,
+            field,
+            key,
+            value,
+            f, fLen;
+
+        if (writeAll) {
+            fLen = fieldItems.length;
+
+            for (f = 0; f < fLen; f++) {
+                field = fieldItems[f];
+                if (field.persist) {
+                    name = field[nameProperty] || field.name;
+                    value = record.get(field.name);
+                    if (field.serialize) {
+                        data[name] = field.serialize(value, record);
+                    } else if (field.type === Ext.data.Types.DATE && field.dateFormat) {
+                        data[name] = Ext.Date.format(value, field.dateFormat);
+                    } else {
+                        data[name] = value;
+                    }
+                }
+            }
+        } else {
+            
+            changes = record.getChanges();
+            for (key in changes) {
+                if (changes.hasOwnProperty(key)) {
+                    field = fields.get(key);
+                    if (field.persist) {
+                        name = field[nameProperty] || field.name;
+                        value = record.get(field.name);
+                        if (field.serialize) {
+                            data[name] = field.serialize(value, record);
+                        } else if (field.type === Ext.data.Types.DATE && field.dateFormat) {
+                            data[name] = Ext.Date.format(value, field.dateFormat);
+                        } else {
+                            data[name] = value;
+                        }
+                    }
+                }
+            }
+        }
+        if (isPhantom) {
+            if (clientIdProperty && operation && operation.records.length > 1) {
+                
+                
+                data[clientIdProperty] = record.internalId;
+            }
+        } else {
+            
+            data[record.idProperty] = record.getId();
+        }
+
+        return data;
+    }
+});
+
+
+Ext.define('Ext.data.writer.Json', {
+    extend: 'Ext.data.writer.Writer',
+    alternateClassName: 'Ext.data.JsonWriter',
+    alias: 'writer.json',
+    
+    
+    root: undefined,
+    
+    
+    encode: false,
+    
+    
+    allowSingle: true,
+    
+    
+    writeRecords: function(request, data) {
+        var root = this.root;
+        
+        if (this.allowSingle && data.length == 1) {
+            
+            data = data[0];
+        }
+        
+        if (this.encode) {
+            if (root) {
+                
+                request.params[root] = Ext.encode(data);
+            } else {
+            }
+        } else {
+            
+            request.jsonData = request.jsonData || {};
+            if (root) {
+                request.jsonData[root] = data;
+            } else {
+                request.jsonData = data;
+            }
+        }
+        return request;
+    }
+});
+
+
+Ext.define('Ext.data.proxy.Server', {
+    extend: 'Ext.data.proxy.Proxy',
+    alias : 'proxy.server',
+    alternateClassName: 'Ext.data.ServerProxy',
+    uses  : ['Ext.data.Request'],
+
+    
+
+    
+    pageParam: 'page',
+
+    
+    startParam: 'start',
+
+    
+    limitParam: 'limit',
+
+    
+    groupParam: 'group',
+
+    
+    groupDirectionParam: 'groupDir',
+
+    
+    sortParam: 'sort',
+
+    
+    filterParam: 'filter',
+
+    
+    directionParam: 'dir',
+
+    
+    simpleSortMode: false,
+
+    
+    simpleGroupMode: false,
+
+    
+    noCache : true,
+
+    
+    cacheString: "_dc",
+
+    
+    timeout : 30000,
+
+    
+
+    constructor: function(config) {
+        var me = this;
+
+        config = config || {};
+        
+        me.callParent([config]);
+
+        
+        me.extraParams = config.extraParams || {};
+
+        me.api = Ext.apply({}, config.api || me.api);
+        
+
+        
+        me.nocache = me.noCache;
+    },
+
+    
+    create: function() {
+        return this.doRequest.apply(this, arguments);
+    },
+
+    read: function() {
+        return this.doRequest.apply(this, arguments);
+    },
+
+    update: function() {
+        return this.doRequest.apply(this, arguments);
+    },
+
+    destroy: function() {
+        return this.doRequest.apply(this, arguments);
+    },
+
+    
+    setExtraParam: function(name, value) {
+        this.extraParams[name] = value;
+    },
+
+    
+    buildRequest: function(operation) {
+        var me = this,
+            params = Ext.applyIf(operation.params || {}, me.extraParams || {}),
+            request;
+
+        
+        params = Ext.applyIf(params, me.getParams(operation));
+
+        if (operation.id !== undefined && params.id === undefined) {
+            params.id = operation.id;
+        }
+
+        request = new Ext.data.Request({
+            params   : params,
+            action   : operation.action,
+            records  : operation.records,
+            operation: operation,
+            url      : operation.url,
+
+            
+            
+            proxy: me
+        });
+
+        request.url = me.buildUrl(request);
+
+        
+        operation.request = request;
+
+        return request;
+    },
+
+    
+    processResponse: function(success, operation, request, response, callback, scope) {
+        var me = this,
+            reader,
+            result;
+
+        if (success === true) {
+            reader = me.getReader();
+
+            
+            
+            
+            reader.applyDefaults = operation.action === 'read';
+
+            result = reader.read(me.extractResponseData(response));
+
+            if (result.success !== false) {
+                
+                Ext.apply(operation, {
+                    response: response,
+                    resultSet: result
+                });
+
+                operation.commitRecords(result.records);
+                operation.setCompleted();
+                operation.setSuccessful();
+            } else {
+                operation.setException(result.message);
+                me.fireEvent('exception', this, response, operation);
+            }
+        } else {
+            me.setException(operation, response);
+            me.fireEvent('exception', this, response, operation);
+        }
+
+        
+        if (typeof callback == 'function') {
+            callback.call(scope || me, operation);
+        }
+
+        me.afterRequest(request, success);
+    },
+
+    
+    setException: function(operation, response) {
+        operation.setException({
+            status: response.status,
+            statusText: response.statusText
+        });
+    },
+
+    
+    extractResponseData: function(response) {
+        return response;
+    },
+
+    
+    applyEncoding: function(value) {
+        return Ext.encode(value);
+    },
+
+    
+    encodeSorters: function(sorters) {
+        var min = [],
+            length = sorters.length,
+            i = 0;
+
+        for (; i < length; i++) {
+            min[i] = {
+                property : sorters[i].property,
+                direction: sorters[i].direction
+            };
+        }
+        return this.applyEncoding(min);
+
+    },
+
+    
+    encodeFilters: function(filters) {
+        var min = [],
+            length = filters.length,
+            i = 0;
+
+        for (; i < length; i++) {
+            min[i] = {
+                property: filters[i].property,
+                value   : filters[i].value
+            };
+        }
+        return this.applyEncoding(min);
+    },
+
+    
+    getParams: function(operation) {
+        var me = this,
+            params = {},
+            isDef = Ext.isDefined,
+            groupers = operation.groupers,
+            sorters = operation.sorters,
+            filters = operation.filters,
+            page = operation.page,
+            start = operation.start,
+            limit = operation.limit,
+            simpleSortMode = me.simpleSortMode,
+            simpleGroupMode = me.simpleGroupMode,
+            pageParam = me.pageParam,
+            startParam = me.startParam,
+            limitParam = me.limitParam,
+            groupParam = me.groupParam,
+            groupDirectionParam = me.groupDirectionParam,
+            sortParam = me.sortParam,
+            filterParam = me.filterParam,
+            directionParam = me.directionParam;
+
+        if (pageParam && isDef(page)) {
+            params[pageParam] = page;
+        }
+
+        if (startParam && isDef(start)) {
+            params[startParam] = start;
+        }
+
+        if (limitParam && isDef(limit)) {
+            params[limitParam] = limit;
+        }
+
+        if (groupParam && groupers && groupers.length > 0) {
+            
+            if (simpleGroupMode) {
+                params[groupParam] = groupers[0].property;
+                params[groupDirectionParam] = groupers[0].direction || 'ASC';
+            } else {
+                params[groupParam] = me.encodeSorters(groupers);
+            }
+        }
+
+        if (sortParam && sorters && sorters.length > 0) {
+            if (simpleSortMode) {
+                params[sortParam] = sorters[0].property;
+                params[directionParam] = sorters[0].direction;
+            } else {
+                params[sortParam] = me.encodeSorters(sorters);
+            }
+
+        }
+
+        if (filterParam && filters && filters.length > 0) {
+            params[filterParam] = me.encodeFilters(filters);
+        }
+
+        return params;
+    },
+
+    
+    buildUrl: function(request) {
+        var me = this,
+            url = me.getUrl(request);
+
+
+        if (me.noCache) {
+            url = Ext.urlAppend(url, Ext.String.format("{0}={1}", me.cacheString, Ext.Date.now()));
+        }
+
+        return url;
+    },
+
+    
+    getUrl: function(request) {
+        return request.url || this.api[request.action] || this.url;
+    },
+
+    
+    doRequest: function(operation, callback, scope) {
+    },
+
+    
+    afterRequest: Ext.emptyFn,
+
+    onDestroy: function() {
+        Ext.destroy(this.reader, this.writer);
+    }
+});
+
+
+Ext.define('Ext.data.proxy.Ajax', {
+    requires: ['Ext.util.MixedCollection', 'Ext.Ajax'],
+    extend: 'Ext.data.proxy.Server',
+    alias: 'proxy.ajax',
+    alternateClassName: ['Ext.data.HttpProxy', 'Ext.data.AjaxProxy'],
+    
+    
+    actionMethods: {
+        create : 'POST',
+        read   : 'GET',
+        update : 'POST',
+        destroy: 'POST'
+    },
+    
+    
+    
+    doRequest: function(operation, callback, scope) {
+        var writer  = this.getWriter(),
+            request = this.buildRequest(operation, callback, scope);
+            
+        if (operation.allowWrite()) {
+            request = writer.write(request);
+        }
+        
+        Ext.apply(request, {
+            headers       : this.headers,
+            timeout       : this.timeout,
+            scope         : this,
+            callback      : this.createRequestCallback(request, operation, callback, scope),
+            method        : this.getMethod(request),
+            disableCaching: false 
+        });
+        
+        Ext.Ajax.request(request);
+        
+        return request;
+    },
+    
+    
+    getMethod: function(request) {
+        return this.actionMethods[request.action];
+    },
+    
+    
+    createRequestCallback: function(request, operation, callback, scope) {
+        var me = this;
+        
+        return function(options, success, response) {
+            me.processResponse(success, operation, request, response, callback, scope);
+        };
+    }
+}, function() {
+    
+    Ext.data.HttpProxy = this;
+});
+
+
+Ext.define('Ext.data.proxy.Client', {
+    extend: 'Ext.data.proxy.Proxy',
+    alternateClassName: 'Ext.data.ClientProxy',
+    
+    
+    isSynchronous: true,
+
+    
+    clear: function() {
+    }
+});
+
+
+Ext.define('Ext.data.proxy.Memory', {
+    extend: 'Ext.data.proxy.Client',
+    alias: 'proxy.memory',
+    alternateClassName: 'Ext.data.MemoryProxy',
+
+    
+
+    constructor: function(config) {
+        this.callParent([config]);
+
+        
+        this.setReader(this.reader);
+    },
+    
+    
+    updateOperation: function(operation, callback, scope) {
+        var i = 0,
+            recs = operation.getRecords(),
+            len = recs.length;
+            
+        for (i; i < len; i++) {
+            recs[i].commit();
+        }
+        operation.setCompleted();
+        operation.setSuccessful();
+        
+        Ext.callback(callback, scope || this, [operation]);
+    },
+    
+    
+    create: function() {
+        this.updateOperation.apply(this, arguments);
+    },
+    
+    
+    update: function() {
+        this.updateOperation.apply(this, arguments);
+    },
+    
+    
+    destroy: function() {
+        this.updateOperation.apply(this, arguments);
+    },
+
+    
+    read: function(operation, callback, scope) {
+        var me = this;
+
+        operation.resultSet = me.getReader().read(me.data);
+
+        operation.setCompleted();
+        operation.setSuccessful();
+        Ext.callback(callback, scope || me, [operation]);
+    },
+
+    clear: Ext.emptyFn
+});
+
+
+Ext.define('Ext.util.LruCache', {
+    extend: 'Ext.util.HashMap',
+
+    
+
+    constructor: function(config) {
+        Ext.apply(this, config);
+        this.callParent([config]);
+    },
+
+    
+    add: function(key, newValue) {
+        var me = this,
+            existingKey = me.findKey(newValue),
+            entry;
+
+        
+        if (existingKey) {
+            me.unlinkEntry(entry = me.map[existingKey]);
+            entry.prev = me.last;
+            entry.next = null;
+        }
+        
+        else {
+            entry = {
+                prev: me.last,
+                next: null,
+                key: key,
+                value: newValue
+            };
+        }
+
+        
+        if (me.last) {
+            me.last.next = entry;
+        }
+        
+        else {
+            me.first = entry;
+        }
+        me.last = entry;
+        me.callParent([key, entry]);
+        me.prune();
+        return newValue;
+    },
+
+    
+    insertBefore: function(key, newValue, sibling) {
+        var me = this,
+            existingKey,
+            entry;
+
+        
+        
+        if (sibling = this.map[this.findKey(sibling)]) {
+            existingKey = me.findKey(newValue);
+
+            
+            if (existingKey) {
+                me.unlinkEntry(entry = me.map[existingKey]);
+            }
+            
+            else {
+                entry = {
+                    prev: sibling.prev,
+                    next: sibling,
+                    key: key,
+                    value: newValue
+                };
+            }
+
+            if (sibling.prev) {
+                entry.prev.next = entry;
+            } else {
+                me.first = entry;
+            }
+            entry.next = sibling;
+            sibling.prev = entry;
+            me.prune();
+            return newValue;
+        }
+        
+        else {
+            return me.add(key, newValue);
+        }
+    },
+
+    
+    get: function(key) {
+        var entry = this.map[key];
+        if (entry) {
+
+            
+            if (entry.next) {
+                this.moveToEnd(entry);
+            }
+            return entry.value;
+        }
+    },
+
+    
+    removeAtKey: function(key) {
+        this.unlinkEntry(this.map[key]);
+        return this.callParent(arguments);
+    },
+
+    
+    clear: function( initial) {
+        this.first = this.last = null;
+        return this.callParent(arguments);
+    },
+
+    
+    unlinkEntry: function(entry) {
+        
+        if (entry) {
+            if (entry.next) {
+                entry.next.prev = entry.prev;
+            } else {
+                this.last = entry.prev;
+            }
+            if (entry.prev) {
+                entry.prev.next = entry.next;
+            } else {
+                this.first = entry.next;
+            }
+            entry.prev = entry.next = null;
+        }
+    },
+
+    
+    moveToEnd: function(entry) {
+        this.unlinkEntry(entry);
+
+        
+        
+        if (entry.prev = this.last) {
+            this.last.next = entry;
+        }
+        
+        else {
+            this.first = entry;
+        }
+        this.last = entry;
+    },
+
+    
+    getArray: function(isKey) {
+        var arr = [],
+            entry = this.first;
+
+        while (entry) {
+            arr.push(isKey ? entry.key: entry.value);
+            entry = entry.next;
+        }
+        return arr;
+    },
+
+    
+    each: function(fn, scope, reverse) {
+        var me = this,
+            entry = reverse ? me.last : me.first,
+            length = me.length;
+
+        scope = scope || me;
+        while (entry) {
+            if (fn.call(scope, entry.key, entry.value, length) === false) {
+                break;
+            }
+            entry = reverse ? entry.prev : entry.next;
+        }
+        return me;
+    },
+
+    
+    findKey: function(value) {
+        var key,
+            map = this.map;
+
+        for (key in map) {
+            if (map.hasOwnProperty(key) && map[key].value === value) {
+                return key;
+            }
+        }
+        return undefined;
+    },
+
+    
+    prune: function() {
+        var me = this,
+            purgeCount = me.maxSize ? (me.length - me.maxSize) : 0;
+
+        if (purgeCount > 0) {
+            for (; me.first && purgeCount; purgeCount--) {
+                me.removeAtKey(me.first.key);
+            }
+        }
+    }
+
+  
+  
+  
+  
+});
+
+
+Ext.define('Ext.data.Store', {
+    extend: 'Ext.data.AbstractStore',
+
+    alias: 'store.store',
+
+    
+    
+    
+    requires: [
+        'Ext.data.StoreManager',
+        'Ext.data.Model',
+        'Ext.data.proxy.Ajax',
+        'Ext.data.proxy.Memory',
+        'Ext.data.reader.Json',
+        'Ext.data.writer.Json',
+        'Ext.util.LruCache'
+    ],
+
+    uses: [
+        'Ext.ModelManager',
+        'Ext.util.Grouper'
+    ],
+
+    remoteSort: false,
+    remoteFilter: false,
+
+    
+    remoteGroup : false,
+
+    
+
+    
+
+    
+    groupField: undefined,
+
+    
+    groupDir: "ASC",
+
+    
+    trailingBufferZone: 25,
+
+    
+    leadingBufferZone: 200,
+
+    
+    pageSize: undefined,
+
+    
+    currentPage: 1,
+
+    
+    clearOnPageLoad: true,
+
+    
+    loading: false,
+
+    
+    sortOnFilter: true,
+
+    
+    buffered: false,
+
+    
+    purgePageCount: 5,
+
+    
+    clearRemovedOnLoad: true,
+
+    defaultPageSize: 25,
+
+    
+    addRecordsOptions: {
+        addRecords: true
+    },
+
+    statics: {
+        recordIdFn: function(record) {
+            return record.internalId;
+        },
+        recordIndexFn: function(record) {
+            return record.index;
+        }
+    },
+
+    onClassExtended: function(cls, data, hooks) {
+        var model = data.model,
+            onBeforeClassCreated;
+
+        if (typeof model == 'string') {
+            onBeforeClassCreated = hooks.onBeforeCreated;
+
+            hooks.onBeforeCreated = function() {
+                var me = this,
+                    args = arguments;
+
+                Ext.require(model, function() {
+                    onBeforeClassCreated.apply(me, args);
+                });
+            };
+        }
+    },
+
+    
+    constructor: function(config) {
+        
+        config = Ext.Object.merge({}, config);
+
+        var me = this,
+            groupers = config.groupers || me.groupers,
+            groupField = config.groupField || me.groupField,
+            proxy,
+            data;
+
+        
+        
+        
+        data = config.data || me.data;
+
+        
+        me.data = new Ext.util.MixedCollection(false, Ext.data.Store.recordIdFn);
+
+        if (data) {
+            me.inlineData = data;
+            delete config.data;
+        }
+
+        if (!groupers && groupField) {
+            groupers = [{
+                property : groupField,
+                direction: config.groupDir || me.groupDir
+            }];
+        }
+        delete config.groupers;
+
+        
+        me.groupers = new Ext.util.MixedCollection();
+        me.groupers.addAll(me.decodeGroupers(groupers));
+
+        this.callParent([config]);
+        
+
+        if (me.buffered) {
+
+            
+            me.pageMap = new me.PageMap({
+                pageSize: me.pageSize,
+                maxSize: me.purgePageCount,
+                listeners: {
+                    
+                    
+                    clear: me.cancelAllPrefetches,
+                    scope: me
+                }
+            });
+            me.pageRequests = {};
+
+            me.sortOnLoad = false;
+            me.filterOnLoad = false;
+        }
+
+        
+        if (me.remoteGroup) {
+            me.remoteSort = true;
+        }
+        if (me.groupers.items.length && !me.remoteGroup) {
+            me.sort(me.groupers.items, 'prepend', false);
+        }
+
+        proxy = me.proxy;
+        data = me.inlineData;
+
+        
+        
+        if (!me.buffered && !me.pageSize) {
+            me.pageSize = me.defaultPageSize;
+        }
+
+        if (data) {
+            if (proxy instanceof Ext.data.proxy.Memory) {
+                proxy.data = data;
+                me.read();
+            } else {
+                me.add.apply(me, [data]);
+            }
+
+            me.sort();
+            delete me.inlineData;
+        } else if (me.autoLoad) {
+            Ext.defer(me.load, 10, me, [ typeof me.autoLoad === 'object' ? me.autoLoad : undefined ]);
+            
+            
+        }
+    },
+
+     
+     
+    destroyStore: function() {
+        this.callParent(arguments);
+
+        
+        
+        
+        if (this.pageMap) {
+            this.pageMap.clear();
+        }
+    },
+
+    onBeforeSort: function() {
+        var groupers = this.groupers;
+        if (groupers.getCount() > 0) {
+            this.sort(groupers.items, 'prepend', false);
+        }
+    },
+
+    
+    decodeGroupers: function(groupers) {
+        if (!Ext.isArray(groupers)) {
+            if (groupers === undefined) {
+                groupers = [];
+            } else {
+                groupers = [groupers];
+            }
+        }
+
+        var length = groupers.length,
+            Grouper = Ext.util.Grouper,
+            config, i, result = [];
+
+        for (i = 0; i < length; i++) {
+            config = groupers[i];
+
+            if (!(config instanceof Grouper)) {
+                if (Ext.isString(config)) {
+                    config = {
+                        property: config
+                    };
+                }
+
+                config = Ext.apply({
+                    root     : 'data',
+                    direction: "ASC"
+                }, config);
+
+                
+                if (config.fn) {
+                    config.sorterFn = config.fn;
+                }
+
+                
+                if (typeof config == 'function') {
+                    config = {
+                        sorterFn: config
+                    };
+                }
+
+                
+                result.push(new Grouper(config));
+            } else {
+                result.push(config);
+            }
+        }
+        return result;
+    },
+
+    
+    group: function(groupers, direction) {
+        var me = this,
+            hasNew = false,
+            grouper,
+            newGroupers;
+
+        if (Ext.isArray(groupers)) {
+            newGroupers = groupers;
+        } else if (Ext.isObject(groupers)) {
+            newGroupers = [groupers];
+        } else if (Ext.isString(groupers)) {
+            grouper = me.groupers.get(groupers);
+
+            if (!grouper) {
+                grouper = {
+                    property : groupers,
+                    direction: direction
+                };
+                newGroupers = [grouper];
+            } else if (direction === undefined) {
+                grouper.toggle();
+            } else {
+                grouper.setDirection(direction);
+            }
+        }
+
+        if (newGroupers && newGroupers.length) {
+            hasNew = true;
+            newGroupers = me.decodeGroupers(newGroupers);
+            me.groupers.clear();
+            me.groupers.addAll(newGroupers);
+        }
+
+        if (me.remoteGroup) {
+            if (me.buffered) {
+                me.pageMap.clear();
+                me.loadPage(1, { groupChange: true });
+            } else {
+                me.load({
+                    scope: me,
+                    callback: me.fireGroupChange
+                });
+            }
+        } else {
+            
+            me.sort(null, null, null, hasNew);
+            me.fireGroupChange();
+        }
+    },
+
+    
+    clearGrouping: function() {
+        var me       = this,
+            groupers = me.groupers.items,
+            gLen     = groupers.length,
+            grouper, g;
+
+        for (g = 0; g < gLen; g++) {
+            grouper = groupers[g];
+
+            me.sorters.remove(grouper);
+        }
+        me.groupers.clear();
+        if (me.remoteGroup) {
+            if (me.buffered) {
+                me.pageMap.clear();
+                me.loadPage(1, { groupChange: true });
+            } else {
+                me.load({
+                    scope: me,
+                    callback: me.fireGroupChange
+                });
+            }
+        } else {
+            me.sort();
+            me.fireGroupChange();
+        }
+    },
+
+    
+    isGrouped: function() {
+        return this.groupers.getCount() > 0;
+    },
+
+    
+    fireGroupChange: function() {
+        this.fireEvent('groupchange', this, this.groupers);
+    },
+
+    
+    getGroups: function(requestGroupString) {
+        var records = this.data.items,
+            length = records.length,
+            groups = [],
+            pointers = {},
+            record,
+            groupStr,
+            group,
+            i;
+
+        for (i = 0; i < length; i++) {
+            record = records[i];
+            groupStr = this.getGroupString(record);
+            group = pointers[groupStr];
+
+            if (group === undefined) {
+                group = {
+                    name: groupStr,
+                    children: []
+                };
+
+                groups.push(group);
+                pointers[groupStr] = group;
+            }
+
+            group.children.push(record);
+        }
+
+        return requestGroupString ? pointers[requestGroupString] : groups;
+    },
+
+    
+    getGroupsForGrouper: function(records, grouper) {
+        var length = records.length,
+            groups = [],
+            oldValue,
+            newValue,
+            record,
+            group,
+            i;
+
+        for (i = 0; i < length; i++) {
+            record = records[i];
+            newValue = grouper.getGroupString(record);
+
+            if (newValue !== oldValue) {
+                group = {
+                    name: newValue,
+                    grouper: grouper,
+                    records: []
+                };
+                groups.push(group);
+            }
+
+            group.records.push(record);
+
+            oldValue = newValue;
+        }
+
+        return groups;
+    },
+
+    
+    getGroupsForGrouperIndex: function(records, grouperIndex) {
+        var me = this,
+            groupers = me.groupers,
+            grouper = groupers.getAt(grouperIndex),
+            groups = me.getGroupsForGrouper(records, grouper),
+            length = groups.length,
+            i;
+
+        if (grouperIndex + 1 < groupers.length) {
+            for (i = 0; i < length; i++) {
+                groups[i].children = me.getGroupsForGrouperIndex(groups[i].records, grouperIndex + 1);
+            }
+        }
+
+        for (i = 0; i < length; i++) {
+            groups[i].depth = grouperIndex;
+        }
+
+        return groups;
+    },
+
+    
+    getGroupData: function(sort) {
+        var me = this;
+        if (sort !== false) {
+            me.sort();
+        }
+
+        return me.getGroupsForGrouperIndex(me.data.items, 0);
+    },
+
+    
+    getGroupString: function(instance) {
+        var group = this.groupers.first();
+        if (group) {
+            return instance.get(group.property);
+        }
+        return '';
+    },
+
+    
+    insert: function(index, records) {
+        var me = this,
+            sync = false,
+            i,
+            record,
+            len;
+
+        records = [].concat(records);
+        for (i = 0,len = records.length; i < len; i++) {
+            record = me.createModel(records[i]);
+            record.set(me.modelDefaults);
+            
+            records[i] = record;
+
+            me.data.insert(index + i, record);
+            record.join(me);
+
+            sync = sync || record.phantom === true;
+        }
+
+        if (me.snapshot) {
+            me.snapshot.addAll(records);
+        }
+
+        if (me.requireSort) {
+            
+            me.suspendEvents();
+            me.sort();
+            me.resumeEvents();
+        }
+
+        me.fireEvent('add', me, records, index);
+        me.fireEvent('datachanged', me);
+        if (me.autoSync && sync && !me.autoSyncSuspended) {
+            me.sync();
+        }
+    },
+
+    
+    add: function(records) {
+        
+        if (!Ext.isArray(records)) {
+            records = Array.prototype.slice.apply(arguments);
+        } else {
+            
+            records = records.slice(0);
+        }
+
+        var me = this,
+            i = 0,
+            length = records.length,
+            record,
+            isSorted = !me.remoteSort && me.sorters && me.sorters.items.length;
+
+        
+        
+        if (isSorted && length === 1) {
+            return [ me.addSorted(me.createModel(records[0])) ];
+        }
+
+        for (; i < length; i++) {
+            record = me.createModel(records[i]);
+            
+            records[i] = record;
+        }
+
+        
+        
+        if (isSorted) {
+            me.requireSort = true;
+        }
+
+        me.insert(me.data.length, records);
+        delete me.requireSort;
+
+        return records;
+    },
+
+    
+    addSorted: function(record) {
+        var me = this,
+            index = me.data.findInsertionIndex(record, me.generateComparator());
+
+        me.insert(index, record);
+        return record;
+    },
+
+    
+    createModel: function(record) {
+        if (!record.isModel) {
+            record = Ext.ModelManager.create(record, this.model);
+        }
+
+        return record;
+    },
+
+    
+    each: function(fn, scope) {
+        var data = this.data.items,
+            dLen = data.length,
+            record, d;
+
+        for (d = 0; d < dLen; d++) {
+            record = data[d];
+            if (fn.call(scope || record, record, d, dLen) === false) {
+                break;
+            }
+        }
+    },
+
+    
+    remove: function(records,  isMove) {
+        if (!Ext.isArray(records)) {
+            records = [records];
+        }
+
+        
+        isMove = isMove === true;
+        var me = this,
+            sync = false,
+            i = 0,
+            length = records.length,
+            isNotPhantom,
+            index,
+            record;
+
+        for (; i < length; i++) {
+            record = records[i];
+            index = me.data.indexOf(record);
+
+            if (me.snapshot) {
+                me.snapshot.remove(record);
+            }
+
+            if (index > -1) {
+                isNotPhantom = record.phantom !== true;
+
+                
+                if (!isMove && isNotPhantom) {
+
+                    
+                    
+                    record.removedFrom = index;
+                    me.removed.push(record);
+                }
+
+                record.unjoin(me);
+                me.data.remove(record);
+                sync = sync || isNotPhantom;
+
+                me.fireEvent('remove', me, record, index);
+            }
+        }
+
+        me.fireEvent('datachanged', me);
+        if (!isMove && me.autoSync && sync && !me.autoSyncSuspended) {
+            me.sync();
+        }
+    },
+
+    
+    removeAt: function(index) {
+        var record = this.getAt(index);
+
+        if (record) {
+            this.remove(record);
+        }
+    },
+
+    
+    load: function(options) {
+        var me = this;
+
+        options = options || {};
+
+        if (typeof options == 'function') {
+            options = {
+                callback: options
+            };
+        }
+
+        options.groupers = options.groupers ||  me.groupers.items;
+        options.page = options.page || me.currentPage;
+        options.start = (options.start !== undefined) ? options.start : (options.page - 1) * me.pageSize;
+        options.limit = options.limit || me.pageSize;
+        options.addRecords = options.addRecords || false;
+
+        if (me.buffered) {
+            return me.loadToPrefetch(options);
+        }
+        return me.callParent([options]);
+    },
+
+    reload: function(options) {
+        var me = this,
+            startIdx,
+            endIdx,
+            startPage,
+            endPage,
+            i,
+            waitForReload,
+            bufferZone,
+            records;
+
+        if (!options) {
+            options = {};
+        }
+
+        
+        
+        if (me.buffered) {
+
+            
+            delete me.totalCount;
+
+            waitForReload = function() {
+                if (me.rangeCached(startIdx, endIdx)) {
+                    me.loading = false;
+                    me.pageMap.un('pageAdded', waitForReload);
+                    records = me.pageMap.getRange(startIdx, endIdx);
+                    me.loadRecords(records, {
+                        start: startIdx
+                    });
+                    me.fireEvent('load', me, records, true);
+                }
+            };
+            bufferZone = Math.ceil((me.leadingBufferZone + me.trailingBufferZone) / 2);
+
+            
+            startIdx = options.start || me.getAt(0).index;
+            endIdx = startIdx + (options.count || me.getCount()) - 1;
+
+            
+            startPage = me.getPageFromRecordIndex(Math.max(startIdx - bufferZone, 0));
+            endPage = me.getPageFromRecordIndex(endIdx + bufferZone);
+
+            
+            me.pageMap.clear(true);
+
+            if (me.fireEvent('beforeload', me, options) !== false) {
+                me.loading = true;
+
+                
+                for (i = startPage; i <= endPage; i++) {
+                    me.prefetchPage(i, options);
+                }
+
+                
+                
+                me.pageMap.on('pageAdded', waitForReload);
+            }
+        } else {
+            return me.callParent(arguments);
+        }
+    },
+
+    
+    onProxyLoad: function(operation) {
+        var me = this,
+            resultSet = operation.getResultSet(),
+            records = operation.getRecords(),
+            successful = operation.wasSuccessful();
+
+        if (resultSet) {
+            me.totalCount = resultSet.total;
+        }
+
+        if (successful) {
+            me.loadRecords(records, operation);
+        }
+
+        me.loading = false;
+        if (me.hasListeners.load) {
+            me.fireEvent('load', me, records, successful);
+        }
+
+        
+        
+        if (me.hasListeners.read) {
+            me.fireEvent('read', me, records, successful);
+        }
+
+        
+        Ext.callback(operation.callback, operation.scope || me, [records, operation, successful]);
+    },
+
+    
+    getNewRecords: function() {
+        return this.data.filterBy(this.filterNew).items;
+    },
+
+    
+    getUpdatedRecords: function() {
+        return this.data.filterBy(this.filterUpdated).items;
+    },
+
+    
+    filter: function(filters, value) {
+        if (Ext.isString(filters)) {
+            filters = {
+                property: filters,
+                value: value
+            };
+        }
+
+        var me = this,
+            decoded = me.decodeFilters(filters),
+            i = 0,
+            doLocalSort = me.sorters.length && me.sortOnFilter && !me.remoteSort,
+            length = decoded.length;
+
+        for (; i < length; i++) {
+            me.filters.replace(decoded[i]);
+        }
+
+        if (me.remoteFilter) {
+            
+            delete me.totalCount;
+            
+            
+            
+            
+            if (me.buffered) {
+                me.pageMap.clear();
+                me.loadPage(1);
+            } else {
+                
+                me.currentPage = 1;
+                
+                me.load();
+            }
+        } else {
+            
+            if (me.filters.getCount()) {
+                me.snapshot = me.snapshot || me.data.clone();
+                me.data = me.data.filter(me.filters.items);
+
+                if (doLocalSort) {
+                    me.sort();
+                } else {
+                    
+                    me.fireEvent('datachanged', me);
+                    me.fireEvent('refresh', me);
+                }
+            }
+        }
+    },
+
+    
+    clearFilter: function(suppressEvent) {
+        var me = this;
+
+        me.filters.clear();
+
+        if (me.remoteFilter) {
+
+            
+            if (suppressEvent) {
+                return;
+            }
+
+            
+            delete me.totalCount;
+
+            
+            
+            
+            if (me.buffered) {
+                me.pageMap.clear();
+                me.loadPage(1);
+            } else {
+                
+                me.currentPage = 1;
+                me.load();
+            }
+        } else if (me.isFiltered()) {
+            me.data = me.snapshot.clone();
+            delete me.snapshot;
+
+            if (suppressEvent !== true) {
+                me.fireEvent('datachanged', me);
+                me.fireEvent('refresh', me);
+            }
+        }
+    },
+
+    
+    isFiltered: function() {
+        var snapshot = this.snapshot;
+        return !! snapshot && snapshot !== this.data;
+    },
+
+    
+    filterBy: function(fn, scope) {
+        var me = this;
+
+        me.snapshot = me.snapshot || me.data.clone();
+        me.data = me.queryBy(fn, scope || me);
+        me.fireEvent('datachanged', me);
+        me.fireEvent('refresh', me);
+    },
+
+    
+    queryBy: function(fn, scope) {
+        var me = this,
+            data = me.snapshot || me.data;
+        return data.filterBy(fn, scope || me);
+    },
+
+    
+    query: function(property, value, anyMatch, caseSensitive, exactMatch) {
+        var me = this,
+            queryFn = me.createFilterFn(property, value, anyMatch, caseSensitive, exactMatch),
+            results = me.queryBy(queryFn);
+
+        
+        if(!results) {
+            results = new Ext.util.MixedCollection();
+        }
+
+        return results;
+    },
+
+    
+    loadData: function(data, append) {
+        var me = this,
+            model = me.model,
+            length = data.length,
+            newData = [],
+            i,
+            record;
+
+        
+        for (i = 0; i < length; i++) {
+            record = data[i];
+
+            if (!(record.isModel)) {
+                record = Ext.ModelManager.create(record, model);
+            }
+            newData.push(record);
+        }
+
+        me.loadRecords(newData, append ? me.addRecordsOptions : undefined);
+    },
+
+    
+    loadRawData : function(data, append) {
+         var me      = this,
+             result  = me.proxy.reader.read(data),
+             records = result.records;
+
+         if (result.success) {
+             me.totalCount = result.total;
+             me.loadRecords(records, append ? me.addRecordsOptions : undefined);
+             me.fireEvent('load', me, records, true);
+         }
+     },
+
+    
+    loadRecords: function(records, options) {
+        var me     = this,
+            i      = 0,
+            length = records.length,
+            start,
+            addRecords,
+            snapshot = me.snapshot;
+
+        if (options) {
+            start = options.start;
+            addRecords = options.addRecords;
+        }
+
+        if (!addRecords) {
+            delete me.snapshot;
+            me.clearData(true);
+        } else if (snapshot) {
+            snapshot.addAll(records);
+        }
+
+        me.data.addAll(records);
+
+        if (start !== undefined) {
+            for (; i < length; i++) {
+                records[i].index = start + i;
+                records[i].join(me);
+            }
+        } else {
+            for (; i < length; i++) {
+                records[i].join(me);
+            }
+        }
+
+        
+        me.suspendEvents();
+
+        if (me.filterOnLoad && !me.remoteFilter) {
+            me.filter();
+        }
+
+        if (me.sortOnLoad && !me.remoteSort) {
+            me.sort(undefined, undefined, undefined, true);
+        }
+
+        me.resumeEvents();
+        me.fireEvent('datachanged', me);
+        me.fireEvent('refresh', me);
+    },
+
+    
+    
+    loadPage: function(page, options) {
+        var me = this;
+
+        me.currentPage = page;
+
+        
+        options = Ext.apply({
+            page: page,
+            start: (page - 1) * me.pageSize,
+            limit: me.pageSize,
+            addRecords: !me.clearOnPageLoad
+        }, options);
+
+        if (me.buffered) {
+            return me.loadToPrefetch(options);
+        }
+        me.read(options);
+    },
+
+    
+    nextPage: function(options) {
+        this.loadPage(this.currentPage + 1, options);
+    },
+
+    
+    previousPage: function(options) {
+        this.loadPage(this.currentPage - 1, options);
+    },
+
+    
+    clearData: function(isLoad) {
+        var me = this,
+            records = me.data.items,
+            i = records.length;
+
+        while (i--) {
+            records[i].unjoin(me);
+        }
+        me.data.clear();
+        if (isLoad !== true || me.clearRemovedOnLoad) {
+            me.removed.length = 0;
+        }
+    },
+
+    loadToPrefetch: function(options) {
+        var me = this,
+            i,
+            records,
+
+            
+            startIdx = options.start,
+            endIdx = options.start + options.limit - 1,
+
+            
+            loadEndIdx = options.start + (me.viewSize || options.limit) - 1,
+
+            
+            startPage = me.getPageFromRecordIndex(Math.max(startIdx - me.trailingBufferZone, 0)),
+            endPage = me.getPageFromRecordIndex(endIdx + me.leadingBufferZone),
+
+            
+            waitForRequestedRange = function() {
+                if (me.rangeCached(startIdx, loadEndIdx)) {
+                    me.loading = false;
+                    records = me.pageMap.getRange(startIdx, loadEndIdx);
+                    me.pageMap.un('pageAdded', waitForRequestedRange);
+
+                    
+                    if (me.hasListeners.guaranteedrange) {
+                        me.guaranteeRange(startIdx, loadEndIdx, options.callback, options.scope);
+                    }
+                    
+                    else {
+                        me.loadRecords(records, {
+                            start: startIdx
+                        });
+                    }
+                    me.fireEvent('load', me, records, true);
+                    if (options.groupChange) {
+                        me.fireGroupChange();
+                    }
+                }
+            };
+
+        if (me.fireEvent('beforeload', me, options) !== false) {
+
+            
+            delete me.totalCount;
+
+            me.loading = true;
+
+            
+            me.pageMap.on('pageAdded', waitForRequestedRange);
+            
+            
+            
+            
+            
+            me.on('prefetch', function(){
+                for (i = startPage + 1; i <= endPage; ++i) {
+                    me.prefetchPage(i, options);
+                }
+            }, null, {single: true});
+            
+            me.prefetchPage(startPage, options);
+        }
+    },
+
+    
+    
+    prefetch: function(options) {
+        var me = this,
+            pageSize = me.pageSize,
+            proxy,
+            operation;
+
+        
+        if (pageSize) {
+            if (me.lastPageSize && pageSize != me.lastPageSize) {
+                Ext.error.raise("pageSize cannot be dynamically altered");
+            }
+            if (!me.pageMap.pageSize) {
+                me.pageMap.pageSize = pageSize;
+            }
+        }
+
+        
+        else {
+            me.pageSize = me.pageMap.pageSize = pageSize = options.limit;
+        }
+
+        
+        me.lastPageSize = pageSize;
+
+        
+        if (!options.page) {
+            options.page = me.getPageFromRecordIndex(options.start);
+            options.start = (options.page - 1) * pageSize;
+            options.limit = Math.ceil(options.limit / pageSize) * pageSize;
+        }
+
+        
+        if (!me.pageRequests[options.page]) {
+
+            
+            options = Ext.apply({
+                action : 'read',
+                filters: me.filters.items,
+                sorters: me.sorters.items,
+                groupers: me.groupers.items,
+
+                
+                
+                generation: me.pageMap.generation
+            }, options);
+
+            operation = new Ext.data.Operation(options);
+
+            if (me.fireEvent('beforeprefetch', me, operation) !== false) {
+                me.loading = true;
+                proxy = me.proxy;
+                me.pageRequests[options.page] = proxy.read(operation, me.onProxyPrefetch, me);
+                if (proxy.isSynchronous) {
+                    delete me.pageRequests[options.page];
+                }
+            }
+        }
+
+        return me;
+    },
+
+    
+    cancelAllPrefetches: function() {
+        var me = this,
+            reqs = me.pageRequests,
+            req,
+            page;
+
+        
+        if (me.pageMap.events.pageadded) {
+            me.pageMap.events.pageadded.clearListeners();
+        }
+
+        
+        for (page in reqs) {
+            if (reqs.hasOwnProperty(page)) {
+                req = reqs[page];
+                delete reqs[page];
+                delete req.callback;
+            }
+        }
+    },
+
+    
+    prefetchPage: function(page, options) {
+        var me = this,
+            pageSize = me.pageSize || me.defaultPageSize,
+            start = (page - 1) * me.pageSize,
+            total = me.totalCount;
+
+        
+        if (total !== undefined && me.getCount() === total) {
+            return;
+        }
+
+        
+        me.prefetch(Ext.applyIf({
+            page     : page,
+            start    : start,
+            limit    : pageSize
+        }, options));
+    },
+
+    
+    onProxyPrefetch: function(operation) {
+        var me = this,
+            resultSet = operation.getResultSet(),
+            records = operation.getRecords(),
+            successful = operation.wasSuccessful(),
+            page = operation.page;
+
+        
+        
+        if (operation.generation === me.pageMap.generation) {
+
+            if (resultSet) {
+                me.totalCount = resultSet.total;
+                me.fireEvent('totalcountchange', me.totalCount);
+            }
+
+            
+            if (page !== undefined) {
+                delete me.pageRequests[page];
+            }
+
+            
+            
+            if (successful) {
+                me.cachePage(records, operation.page);
+            }
+
+            me.loading = false;
+            me.fireEvent('prefetch', me, records, successful, operation);
+
+            
+            Ext.callback(operation.callback, operation.scope || me, [records, operation, successful]);
+        }
+    },
+
+    
+    cachePage: function(records, page) {
+        var me = this;
+
+        if (!Ext.isDefined(me.totalCount)) {
+            me.totalCount = records.length;
+            me.fireEvent('totalcountchange', me.totalCount);
+        }
+
+        
+        me.pageMap.addPage(page, records);
+    },
+
+    
+    rangeCached: function(start, end) {
+        return this.pageMap && this.pageMap.hasRange(start, end);
+    },
+
+    
+    pageCached: function(page) {
+        return this.pageMap && this.pageMap.hasPage(page);
+    },
+
+    
+    rangeSatisfied: function(start, end) {
+        return this.rangeCached(start, end);
+    },
+
+    
+    getPageFromRecordIndex: function(index) {
+        return Math.floor(index / this.pageSize) + 1;
+    },
+
+    
+    onGuaranteedRange: function(options) {
+        var me = this,
+            totalCount = me.getTotalCount(),
+            start = options.prefetchStart,
+            end = ((totalCount - 1) < options.prefetchEnd) ? totalCount - 1 : options.prefetchEnd,
+            range;
+
+        end = Math.max(0, end);
+
+
+        range = me.pageMap.getRange(start, end);
+        me.fireEvent('guaranteedrange', range, start, end);
+        if (options.cb) {
+            options.cb.call(options.scope || me, range, start, end);
+        }
+    },
+
+    
+    prefetchRange: function(start, end) {
+        var me = this,
+            startPage, endPage, page;
+        if (!me.rangeCached(start, end)) {
+            startPage = me.getPageFromRecordIndex(start);
+            endPage = me.getPageFromRecordIndex(end);
+
+            
+            
+            
+            me.pageMap.maxSize = me.purgePageCount ? (endPage - startPage + 1) + me.purgePageCount : 0;
+
+            
+            for (page = startPage; page <= endPage; page++) {
+                if (!me.pageCached(page)) {
+                    me.prefetchPage(page);
+                }
+            }
+        }
+    },
+
+    
+    guaranteeRange: function(start, end, cb, scope) {
+        
+        end = (end > this.totalCount) ? this.totalCount - 1 : end;
+
+        var me = this,
+            lastRequestStart = me.lastRequestStart,
+            options = {
+                prefetchStart: start,
+                prefetchEnd: end,
+                cb: cb,
+                scope: scope
+            },
+            pageAddHandler;
+
+        me.lastRequestStart = start;
+
+        
+        if (me.rangeCached(start, end)) {
+
+            
+            if (start < lastRequestStart) {
+                start = Math.max(start - me.leadingBufferZone, 0);
+                end   = Math.min(end   + me.trailingBufferZone, me.totalCount - 1);
+            } else {
+                start = Math.max(Math.min(start - me.trailingBufferZone, me.totalCount - me.pageSize), 0);
+                end   = Math.min(end + me.leadingBufferZone, me.totalCount - 1);
+            }
+
+            
+            
+            if (!me.rangeCached(start, end)) {
+                
+                me.prefetchRange(start, end);
+            }
+            me.onGuaranteedRange(options);
+        }
+        
+        else {
+            
+            me.fireEvent('cachemiss', me, start, end);
+
+            
+            start = Math.min(Math.max(Math.floor(start - ((me.leadingBufferZone + me.trailingBufferZone) / 2)), 0), me.totalCount - me.pageSize);
+            end =   Math.min(Math.max(Math.ceil (end   + ((me.leadingBufferZone + me.trailingBufferZone) / 2)), 0), me.totalCount - 1);
+
+            
+            pageAddHandler = function(page, records) {
+                if (me.rangeCached(options.prefetchStart, options.prefetchEnd)) {
+                    
+                    me.fireEvent('cachefilled', me, start, end);
+                    me.pageMap.un('pageAdded', pageAddHandler);
+                    me.onGuaranteedRange(options);
+                }
+            };
+            me.pageMap.on('pageAdded', pageAddHandler);
+
+            
+            
+            
+            me.prefetchRange(options.prefetchStart, options.prefetchEnd);
+
+            
+            me.prefetchRange(start, end);
+        }
+    },
+
+    
+    
+    sort: function() {
+        var me = this,
+            prefetchData = me.pageMap;
+
+        if (me.buffered) {
+            if (me.remoteSort) {
+                prefetchData.clear();
+                me.callParent(arguments);
+            } else {
+                me.callParent(arguments);
+            }
+        } else {
+            me.callParent(arguments);
+        }
+    },
+
+    
+    
+    
+    doSort: function(sorterFn) {
+        var me = this,
+            range,
+            ln,
+            i;
+        if (me.remoteSort) {
+
+            
+            
+            
+            if (me.buffered) {
+                me.pageMap.clear();
+                me.loadPage(1);
+            } else {
+                
+                me.load();
+            }
+        } else {
+            me.data.sortBy(sorterFn);
+            if (!me.buffered) {
+                range = me.getRange();
+                ln = range.length;
+                for (i = 0; i < ln; i++) {
+                    range[i].index = i;
+                }
+            }
+            me.fireEvent('datachanged', me);
+            me.fireEvent('refresh', me);
+        }
+    },
+
+    
+    find: function(property, value, start, anyMatch, caseSensitive, exactMatch) {
+        var fn = this.createFilterFn(property, value, anyMatch, caseSensitive, exactMatch);
+        return fn ? this.data.findIndexBy(fn, null, start) : -1;
+    },
+
+    
+    findRecord: function() {
+        var me = this,
+            index = me.find.apply(me, arguments);
+        return index !== -1 ? me.getAt(index) : null;
+    },
+
+    
+    createFilterFn: function(property, value, anyMatch, caseSensitive, exactMatch) {
+        if (Ext.isEmpty(value)) {
+            return false;
+        }
+        value = this.data.createValueMatcher(value, anyMatch, caseSensitive, exactMatch);
+        return function(r) {
+            return value.test(r.data[property]);
+        };
+    },
+
+    
+    findExact: function(property, value, start) {
+        return this.data.findIndexBy(function(rec) {
+            return rec.isEqual(rec.get(property), value);
+        },
+        this, start);
+    },
+
+    
+    findBy: function(fn, scope, start) {
+        return this.data.findIndexBy(fn, scope, start);
+    },
+
+    
+    collect: function(dataIndex, allowNull, bypassFilter) {
+        var me = this,
+            data = (bypassFilter === true && me.snapshot) ? me.snapshot : me.data;
+
+        return data.collect(dataIndex, 'data', allowNull);
+    },
+
+    
+    getCount: function() {
+        return this.data.length || 0;
+    },
+
+    
+    getTotalCount: function() {
+        return this.totalCount || 0;
+    },
+
+    
+    getAt: function(index) {
+        return this.data.getAt(index);
+    },
+
+    
+    getRange: function(start, end) {
+        return this.data.getRange(start, end);
+    },
+
+    
+    getById: function(id) {
+        return (this.snapshot || this.data).findBy(function(record) {
+            return record.getId() === id;
+        });
+    },
+
+    
+    indexOf: function(record) {
+        return this.data.indexOf(record);
+    },
+
+
+    
+    indexOfTotal: function(record) {
+        var index = record.index;
+        if (index || index === 0) {
+            return index;
+        }
+        return this.indexOf(record);
+    },
+
+    
+    indexOfId: function(id) {
+        return this.indexOf(this.getById(id));
+    },
+
+    
+    removeAll: function(silent) {
+        var me = this;
+
+        me.clearData();
+        if (me.snapshot) {
+            me.snapshot.clear();
+        }
+
+        
+        
+        if (me.pageMap) {
+            me.pageMap.clear();
+        }
+        if (silent !== true) {
+            me.fireEvent('clear', me);
+        }
+    },
+
+    
+
+    
+    first: function(grouped) {
+        var me = this;
+
+        if (grouped && me.isGrouped()) {
+            return me.aggregate(function(records) {
+                return records.length ? records[0] : undefined;
+            }, me, true);
+        } else {
+            return me.data.first();
+        }
+    },
+
+    
+    last: function(grouped) {
+        var me = this;
+
+        if (grouped && me.isGrouped()) {
+            return me.aggregate(function(records) {
+                var len = records.length;
+                return len ? records[len - 1] : undefined;
+            }, me, true);
+        } else {
+            return me.data.last();
+        }
+    },
+
+    
+    sum: function(field, grouped) {
+        var me = this;
+
+        if (grouped && me.isGrouped()) {
+            return me.aggregate(me.getSum, me, true, [field]);
+        } else {
+            return me.getSum(me.data.items, field);
+        }
+    },
+
+    
+    getSum: function(records, field) {
+        var total = 0,
+            i = 0,
+            len = records.length;
+
+        for (; i < len; ++i) {
+            total += records[i].get(field);
+        }
+
+        return total;
+    },
+
+    
+    count: function(grouped) {
+        var me = this;
+
+        if (grouped && me.isGrouped()) {
+            return me.aggregate(function(records) {
+                return records.length;
+            }, me, true);
+        } else {
+            return me.getCount();
+        }
+    },
+
+    
+    min: function(field, grouped) {
+        var me = this;
+
+        if (grouped && me.isGrouped()) {
+            return me.aggregate(me.getMin, me, true, [field]);
+        } else {
+            return me.getMin(me.data.items, field);
+        }
+    },
+
+    
+    getMin: function(records, field) {
+        var i = 1,
+            len = records.length,
+            value, min;
+
+        if (len > 0) {
+            min = records[0].get(field);
+        }
+
+        for (; i < len; ++i) {
+            value = records[i].get(field);
+            if (value < min) {
+                min = value;
+            }
+        }
+        return min;
+    },
+
+    
+    max: function(field, grouped) {
+        var me = this;
+
+        if (grouped && me.isGrouped()) {
+            return me.aggregate(me.getMax, me, true, [field]);
+        } else {
+            return me.getMax(me.data.items, field);
+        }
+    },
+
+    
+    getMax: function(records, field) {
+        var i = 1,
+            len = records.length,
+            value,
+            max;
+
+        if (len > 0) {
+            max = records[0].get(field);
+        }
+
+        for (; i < len; ++i) {
+            value = records[i].get(field);
+            if (value > max) {
+                max = value;
+            }
+        }
+        return max;
+    },
+
+    
+    average: function(field, grouped) {
+        var me = this;
+        if (grouped && me.isGrouped()) {
+            return me.aggregate(me.getAverage, me, true, [field]);
+        } else {
+            return me.getAverage(me.data.items, field);
+        }
+    },
+
+    
+    getAverage: function(records, field) {
+        var i = 0,
+            len = records.length,
+            sum = 0;
+
+        if (records.length > 0) {
+            for (; i < len; ++i) {
+                sum += records[i].get(field);
+            }
+            return sum / len;
+        }
+        return 0;
+    },
+
+    
+    aggregate: function(fn, scope, grouped, args) {
+        args = args || [];
+        if (grouped && this.isGrouped()) {
+            var groups = this.getGroups(),
+                i = 0,
+                len = groups.length,
+                out = {},
+                group;
+
+            for (; i < len; ++i) {
+                group = groups[i];
+                out[group.name] = fn.apply(scope || this, [group.children].concat(args));
+            }
+            return out;
+        } else {
+            return fn.apply(scope || this, [this.data.items].concat(args));
+        }
+    },
+
+    
+    commitChanges : function(){
+        var me = this,
+            recs = me.getModifiedRecords(),
+            len = recs.length,
+            i = 0;
+
+        for (; i < len; i++){
+            recs[i].commit();
+        }
+
+        
+        
+        me.removed.length = 0;
+    },
+
+    filterNewOnly: function(item){
+        return item.phantom === true;
+    },
+
+    
+    
+    
+    getRejectRecords: function() {
+        
+        return Ext.Array.push(this.data.filterBy(this.filterNewOnly).items, this.getUpdatedRecords());
+    },
+
+    
+    rejectChanges : function() {
+        var me = this,
+            recs = me.getRejectRecords(),
+            len = recs.length,
+            i = 0,
+            rec;
+
+        for (; i < len; i++) {
+            rec = recs[i];
+            rec.reject();
+            if (rec.phantom) {
+                me.remove(rec);
+            }
+        }
+
+        
+        recs = me.removed;
+        len = recs.length;
+        for (i = 0; i < len; i++) {
+            rec = recs[i];
+            me.insert(rec.removedFrom || 0, rec);
+            rec.reject();
+        }
+
+        
+        
+        me.removed.length = 0;
+    }
+}, function() {
+    
+    
+    
+    Ext.regStore('ext-empty-store', {fields: [], proxy: 'memory'});
+
+    
+    this.prototype.PageMap = new Ext.Class({
+        extend: 'Ext.util.LruCache',
+
+        
+        clear: function(initial) {
+            this.generation = (this.generation ||0) + 1;
+            this.callParent(arguments);
+        },
+
+        getPageFromRecordIndex: this.prototype.getPageFromRecordIndex,
+
+        addPage: function(page, records) {
+            this.add(page, records);
+            this.fireEvent('pageAdded', page, records);
+        },
+
+        getPage: function(page) {
+            return this.get(page);
+        },
+
+        hasRange: function(start, end) {
+            var page = this.getPageFromRecordIndex(start),
+                endPage = this.getPageFromRecordIndex(end);
+
+            for (; page <= endPage; page++) {
+                if (!this.hasPage(page)) {
+                    return false;
+                }
+            }
+            return true;
+        },
+
+        hasPage: function(page) {
+            
+            return !!this.get(page);
+        },
+
+        getRange: function(start, end) {
+            if (!this.hasRange(start, end)) {
+                Ext.Error.raise('PageMap asked for range which it does not have');
+            }
+            var me = this,
+                startPage = me.getPageFromRecordIndex(start),
+                endPage = me.getPageFromRecordIndex(end),
+                dataStart = (startPage - 1) * me.pageSize,
+                dataEnd = (endPage * me.pageSize) - 1,
+                page = startPage,
+                result = [],
+                sliceBegin, sliceEnd, doSlice,
+                i = 0, len;
+
+            for (; page <= endPage; page++) {
+
+                
+                if (page == startPage) {
+                    sliceBegin = start - dataStart;
+                    doSlice = true;
+                } else {
+                    sliceBegin = 0;
+                    doSlice = false;
+                }
+                if (page == endPage) {
+                    sliceEnd = me.pageSize - (dataEnd - end);
+                    doSlice = true;
+                }
+
+                
+                if (doSlice) {
+                    Ext.Array.push(result, Ext.Array.slice(me.getPage(page), sliceBegin, sliceEnd));
+                } else {
+                    Ext.Array.push(result, me.getPage(page));
+                }
+            }
+
+            
+            for (len = result.length; i < len; i++) {
+                result[i].index = start++;
+            }
+            return result;
+        }
+    });
+});
+
+
+Ext.define('Ext.data.reader.Array', {
+    extend: 'Ext.data.reader.Json',
+    alternateClassName: 'Ext.data.ArrayReader',
+    alias : 'reader.array',
+
+    
+    totalProperty: undefined,
+    successProperty: undefined,
+
+    
+    createFieldAccessExpression: function(field, fieldVarName, dataName) {
+            
+            
+        var index  = (field.mapping == null) ? field.originalIndex : field.mapping,
+            result;
+
+        if (typeof index === 'function') {
+            result = fieldVarName + '.mapping(' + dataName + ', this)';
+        } else {
+            if (isNaN(index)) {
+                index = '"' + index + '"';
+            }
+            result = dataName + "[" + index + "]";
+        }
+        return result;
+    }
+});
+
+
+Ext.define('Ext.data.ArrayStore', {
+    extend: 'Ext.data.Store',
+    alias: 'store.array',
+    requires: [
+        'Ext.data.proxy.Memory',
+        'Ext.data.reader.Array'
+    ],
+
+    constructor: function(config) {
+        config = Ext.apply({
+            proxy: {
+                type: 'memory',
+                reader: 'array'
+            }
+        }, config);
+        this.callParent([config]);
+    },
+
+    loadData: function(data, append) {
+        if (this.expandData === true) {
+            var r = [],
+                i = 0,
+                ln = data.length;
+
+            for (; i < ln; i++) {
+                r[r.length] = [data[i]];
+            }
+
+            data = r;
+        }
+
+        this.callParent([data, append]);
+    }
+}, function() {
+    
+    Ext.data.SimpleStore = Ext.data.ArrayStore;
+    
+});
+
+
+Ext.define('Ext.data.Batch', {
+    mixins: {
+        observable: 'Ext.util.Observable'
+    },
+
+    
+    autoStart: false,
+    
+    
+    pauseOnException: false,
+
+    
+    current: -1,
+
+    
+    total: 0,
+
+    
+    isRunning: false,
+
+    
+    isComplete: false,
+
+    
+    hasException: false,
+
+    
+    constructor: function(config) {
+        var me = this;
+
+        
+
+        
+
+        
+
+        me.mixins.observable.constructor.call(me, config);
+
+        
+        me.operations = [];
+        
+        
+        me.exceptions = [];
+    },
+
+    
+    add: function(operation) {
+        this.total++;
+
+        operation.setBatch(this);
+
+        this.operations.push(operation);
+        
+        return this;
+    },
+
+    
+    start: function( index) {
+        var me = this;
+        
+        if (me.isRunning) {
+            return me;
+        }
+        
+        me.exceptions.length = 0;
+        me.hasException = false;
+        me.isRunning = true;
+
+        return me.runOperation(Ext.isDefined(index) ? index : me.current + 1);
+    },
+    
+    
+    retry: function() {
+        return this.start(this.current);
+    },
+
+    
+    runNextOperation: function() {
+        return this.runOperation(this.current + 1);
+    },
+
+    
+    pause: function() {
+        this.isRunning = false;
+        return this;
+    },
+
+    
+    runOperation: function(index) {
+        var me = this,
+            operations = me.operations,
+            operation = operations[index],
+            onProxyReturn;
+
+        if (operation === undefined) {
+            me.isRunning = false;
+            me.isComplete = true;
+            me.fireEvent('complete', me, operations[operations.length - 1]);
+        } else {
+            me.current = index;
+
+            onProxyReturn = function(operation) {
+                var hasException = operation.hasException();
+
+                if (hasException) {
+                    me.hasException = true;
+                    me.exceptions.push(operation);
+                    me.fireEvent('exception', me, operation);
+                }
+
+                if (hasException && me.pauseOnException) {
+                    me.pause();
+                } else {
+                    operation.setCompleted();
+                    me.fireEvent('operationcomplete', me, operation);
+                    me.runNextOperation();
+                }
+            };
+
+            operation.setStarted();
+
+            me.proxy[operation.action](operation, onProxyReturn, me);
+        }
+        
+        return me;
+    }
+});
+
+
+Ext.define('Ext.data.BufferStore', {
+    extend: 'Ext.data.Store',
+    alias: 'store.buffer',
+    sortOnLoad: false,
+    filterOnLoad: false,
+    
+    constructor: function() {
+        Ext.Error.raise('The BufferStore class has been deprecated. Instead, specify the buffered config option on Ext.data.Store');
+    }
+});
+
+
+Ext.define('Ext.direct.Manager', {
+
+    
+    singleton: true,
+
+    mixins: {
+        observable: 'Ext.util.Observable'
+    },
+
+    requires: ['Ext.util.MixedCollection'],
+
+    
+    exceptions: {
+        TRANSPORT: 'xhr',
+        PARSE: 'parse',
+        LOGIN: 'login',
+        SERVER: 'exception'
+    },
+
+    
+
+    constructor: function(){
+        var me = this;
+
+        me.addEvents(
+            
+            'event',
+            
+            'exception'
+        );
+        me.transactions = new Ext.util.MixedCollection();
+        me.providers = new Ext.util.MixedCollection();
+
+        me.mixins.observable.constructor.call(me);
+    },
+
+    
+    addProvider : function(provider){
+        var me = this,
+            args = arguments,
+            i = 0,
+            len;
+
+        if (args.length > 1) {
+            for (len = args.length; i < len; ++i) {
+                me.addProvider(args[i]);
+            }
+            return;
+        }
+
+        
+        if (!provider.isProvider) {
+            provider = Ext.create('direct.' + provider.type + 'provider', provider);
+        }
+        me.providers.add(provider);
+        provider.on('data', me.onProviderData, me);
+
+
+        if (!provider.isConnected()) {
+            provider.connect();
+        }
+
+        return provider;
+    },
+
+    
+    getProvider : function(id){
+        return id.isProvider ? id : this.providers.get(id);
+    },
+
+    
+    removeProvider : function(provider){
+        var me = this,
+            providers = me.providers;
+
+        provider = provider.isProvider ? provider : providers.get(provider);
+
+        if (provider) {
+            provider.un('data', me.onProviderData, me);
+            providers.remove(provider);
+            return provider;
+        }
+        return null;
+    },
+
+    
+    addTransaction: function(transaction){
+        this.transactions.add(transaction);
+        return transaction;
+    },
+
+    
+    removeTransaction: function(transaction){
+        transaction = this.getTransaction(transaction);
+        this.transactions.remove(transaction);
+        return transaction;
+    },
+
+    
+    getTransaction: function(transaction){
+        return Ext.isObject(transaction) ? transaction : this.transactions.get(transaction);
+    },
+
+    onProviderData : function(provider, event){
+        var me = this,
+            i = 0,
+            len;
+
+        if (Ext.isArray(event)) {
+            for (len = event.length; i < len; ++i) {
+                me.onProviderData(provider, event[i]);
+            }
+            return;
+        }
+        if (event.name && event.name != 'event' && event.name != 'exception') {
+            me.fireEvent(event.name, event);
+        } else if (event.status === false) {
+            me.fireEvent('exception', event);
+        }
+        me.fireEvent('event', event, provider);
+    },
+    
+    
+    parseMethod: function(fn){
+        if (Ext.isString(fn)) {
+            var parts = fn.split('.'),
+                i = 0,
+                len = parts.length,
+                current = window;
+                
+            while (current && i < len) {
+                current = current[parts[i]];
+                ++i;
+            }
+            fn = Ext.isFunction(current) ? current : null;
+        }
+        return fn || null;
+    }
+    
+}, function(){
+    
+    Ext.Direct = Ext.direct.Manager;
+});
+
+
+Ext.define('Ext.data.proxy.Direct', {
+    
+
+    extend: 'Ext.data.proxy.Server',
+    alternateClassName: 'Ext.data.DirectProxy',
+
+    alias: 'proxy.direct',
+
+    requires: ['Ext.direct.Manager'],
+
+    
+
+    
+    paramOrder: undefined,
+
+    
+    paramsAsHash: true,
+
+    
+    directFn : undefined,
+
+    
+
+    
+
+    
+    paramOrderRe: /[\s,|]/,
+
+    constructor: function(config){
+        var me = this,
+            paramOrder,
+            fn,
+            api;
+            
+        me.callParent(arguments);
+        
+        paramOrder = me.paramOrder;
+        if (Ext.isString(paramOrder)) {
+            me.paramOrder = paramOrder.split(me.paramOrderRe);
+        }
+        
+        fn = me.directFn;
+        if (fn) {
+            me.directFn = Ext.direct.Manager.parseMethod(fn);
+        }
+        
+        api = me.api;
+        for (fn in api) {
+            if (api.hasOwnProperty(fn)) {
+                api[fn] = Ext.direct.Manager.parseMethod(api[fn]);
+            }
+        }
+    },
+
+    doRequest: function(operation, callback, scope) {
+        var me = this,
+            writer = me.getWriter(),
+            request = me.buildRequest(operation, callback, scope),
+            fn = me.api[request.action]  || me.directFn,
+            params = request.params,
+            args = [],
+            method;
+
+
+        if (operation.allowWrite()) {
+            request = writer.write(request);
+        }
+
+        if (operation.action == 'read') {
+            
+            method = fn.directCfg.method;
+            args = method.getArgs(params, me.paramOrder, me.paramsAsHash);
+        } else {
+            args.push(request.jsonData);
+        }
+
+        Ext.apply(request, {
+            args: args,
+            directFn: fn
+        });
+        args.push(me.createRequestCallback(request, operation, callback, scope), me);
+        fn.apply(window, args);
+    },
+
+    
+    applyEncoding: function(value){
+        return value;
+    },
+
+    createRequestCallback: function(request, operation, callback, scope){
+        var me = this;
+
+        return function(data, event){
+            me.processResponse(event.status, operation, request, event, callback, scope);
+        };
+    },
+
+    
+    extractResponseData: function(response){
+        return Ext.isDefined(response.result) ? response.result : response.data;
+    },
+
+    
+    setException: function(operation, response) {
+        operation.setException(response.message);
+    },
+
+    
+    buildUrl: function(){
+        return '';
+    }
+});
+
+
+Ext.define('Ext.data.DirectStore', {
+    
+    
+    extend: 'Ext.data.Store',
+    
+    alias: 'store.direct',
+    
+    requires: ['Ext.data.proxy.Direct'],
+   
+    
+
+    constructor : function(config){
+        config = Ext.apply({}, config);
+        if (!config.proxy) {
+            var proxy = {
+                type: 'direct',
+                reader: {
+                    type: 'json'
+                }
+            };
+            Ext.copyTo(proxy, config, 'paramOrder,paramsAsHash,directFn,api,simpleSortMode');
+            Ext.copyTo(proxy.reader, config, 'totalProperty,root,idProperty');
+            config.proxy = proxy;
+        }
+        this.callParent([config]);
+    }    
+});
+
+
+Ext.define('Ext.data.JsonP', {
+
+    
+
+    singleton: true,
+
+    
+
+    
+    requestCount: 0,
+
+    
+    requests: {},
+
+    
+    timeout: 30000,
+
+    
+    disableCaching: true,
+
+    
+    disableCachingParam: '_dc',
+
+    
+    callbackKey: 'callback',
+
+    
+    request: function(options){
+        options = Ext.apply({}, options);
+
+
+        var me = this,
+            disableCaching = Ext.isDefined(options.disableCaching) ? options.disableCaching : me.disableCaching,
+            cacheParam = options.disableCachingParam || me.disableCachingParam,
+            id = ++me.requestCount,
+            callbackName = options.callbackName || 'callback' + id,
+            callbackKey = options.callbackKey || me.callbackKey,
+            timeout = Ext.isDefined(options.timeout) ? options.timeout : me.timeout,
+            params = Ext.apply({}, options.params),
+            url = options.url,
+            name = Ext.name,
+            request,
+            script;
+
+        params[callbackKey] = name + '.data.JsonP.' + callbackName;
+        if (disableCaching) {
+            params[cacheParam] = new Date().getTime();
+        }
+
+        script = me.createScript(url, params, options);
+
+        me.requests[id] = request = {
+            url: url,
+            params: params,
+            script: script,
+            id: id,
+            scope: options.scope,
+            success: options.success,
+            failure: options.failure,
+            callback: options.callback,
+            callbackKey: callbackKey,
+            callbackName: callbackName
+        };
+
+        if (timeout > 0) {
+            request.timeout = setTimeout(Ext.bind(me.handleTimeout, me, [request]), timeout);
+        }
+
+        me.setupErrorHandling(request);
+        me[callbackName] = Ext.bind(me.handleResponse, me, [request], true);
+        me.loadScript(request);
+        return request;
+    },
+
+    
+    abort: function(request){
+        var me = this,
+            requests = me.requests,
+            key;
+
+        if (request) {
+            if (!request.id) {
+                request = requests[request];
+            }
+            me.handleAbort(request);
+        } else {
+            for (key in requests) {
+                if (requests.hasOwnProperty(key)) {
+                    me.abort(requests[key]);
+                }
+            }
+        }
+    },
+
+    
+    setupErrorHandling: function(request){
+        request.script.onerror = Ext.bind(this.handleError, this, [request]);
+    },
+
+    
+    handleAbort: function(request){
+        request.errorType = 'abort';
+        this.handleResponse(null, request);
+    },
+
+    
+    handleError: function(request){
+        request.errorType = 'error';
+        this.handleResponse(null, request);
+    },
+
+    
+    cleanupErrorHandling: function(request){
+        request.script.onerror = null;
+    },
+
+    
+    handleTimeout: function(request){
+        request.errorType = 'timeout';
+        this.handleResponse(null, request);
+    },
+
+    
+    handleResponse: function(result, request){
+
+        var success = true;
+
+        if (request.timeout) {
+            clearTimeout(request.timeout);
+        }
+        delete this[request.callbackName];
+        delete this.requests[request.id];
+        this.cleanupErrorHandling(request);
+        Ext.fly(request.script).remove();
+
+        if (request.errorType) {
+            success = false;
+            Ext.callback(request.failure, request.scope, [request.errorType]);
+        } else {
+            Ext.callback(request.success, request.scope, [result]);
+        }
+        Ext.callback(request.callback, request.scope, [success, result, request.errorType]);
+    },
+
+    
+    createScript: function(url, params, options) {
+        var script = document.createElement('script');
+        script.setAttribute("src", Ext.urlAppend(url, Ext.Object.toQueryString(params)));
+        script.setAttribute("async", true);
+        script.setAttribute("type", "text/javascript");
+        return script;
+    },
+
+    
+    loadScript: function (request) {
+        Ext.getHead().appendChild(request.script);
+    }
+});
+
+
+Ext.define('Ext.data.proxy.JsonP', {
+    extend: 'Ext.data.proxy.Server',
+    alternateClassName: 'Ext.data.ScriptTagProxy',
+    alias: ['proxy.jsonp', 'proxy.scripttag'],
+    requires: ['Ext.data.JsonP'],
+
+    defaultWriterType: 'base',
+
+    
+    callbackKey : 'callback',
+
+    
+    recordParam: 'records',
+
+    
+    autoAppendParams: true,
+
+    constructor: function(){
+        this.addEvents(
+            
+            'exception'
+        );
+        this.callParent(arguments);
+    },
+
+    
+    doRequest: function(operation, callback, scope) {
+        
+        var me      = this,
+            writer  = me.getWriter(),
+            request = me.buildRequest(operation),
+            params = request.params;
+
+        if (operation.allowWrite()) {
+            request = writer.write(request);
+        }
+
+        
+        Ext.apply(request, {
+            callbackKey: me.callbackKey,
+            timeout: me.timeout,
+            scope: me,
+            disableCaching: false, 
+            callback: me.createRequestCallback(request, operation, callback, scope)
+        });
+
+        
+        if (me.autoAppendParams) {
+            request.params = {};
+        }
+
+        request.jsonp = Ext.data.JsonP.request(request);
+        
+        request.params = params;
+        operation.setStarted();
+        me.lastRequest = request;
+
+        return request;
+    },
+
+    
+    createRequestCallback: function(request, operation, callback, scope) {
+        var me = this;
+
+        return function(success, response, errorType) {
+            delete me.lastRequest;
+            me.processResponse(success, operation, request, response, callback, scope);
+        };
+    },
+
+    
+    setException: function(operation, response) {
+        operation.setException(operation.request.jsonp.errorType);
+    },
+
+
+    
+    buildUrl: function(request) {
+        var me      = this,
+            url     = me.callParent(arguments),
+            params  = Ext.apply({}, request.params),
+            filters = params.filters,
+            records,
+            filter, i;
+
+        delete params.filters;
+
+        if (me.autoAppendParams) {
+            url = Ext.urlAppend(url, Ext.Object.toQueryString(params));
+        }
+
+        if (filters && filters.length) {
+            for (i = 0; i < filters.length; i++) {
+                filter = filters[i];
+
+                if (filter.value) {
+                    url = Ext.urlAppend(url, filter.property + "=" + filter.value);
+                }
+            }
+        }
+
+        
+        records = request.records;
+
+        if (Ext.isArray(records) && records.length > 0) {
+            url = Ext.urlAppend(url, Ext.String.format("{0}={1}", me.recordParam, me.encodeRecords(records)));
+        }
+
+        return url;
+    },
+
+    
+    destroy: function() {
+        this.abort();
+        this.callParent(arguments);
+    },
+
+    
+    abort: function() {
+        var lastRequest = this.lastRequest;
+        if (lastRequest) {
+            Ext.data.JsonP.abort(lastRequest.jsonp);
+        }
+    },
+
+    
+    encodeRecords: function(records) {
+        var encoded = "",
+            i = 0,
+            len = records.length;
+
+        for (; i < len; i++) {
+            encoded += Ext.Object.toQueryString(records[i].getData());
+        }
+
+        return encoded;
+    }
+});
+
+
+Ext.define('Ext.data.JsonPStore', {
+    extend: 'Ext.data.Store',
+    alias : 'store.jsonp',
+    requires: [
+        'Ext.data.proxy.JsonP',
+        'Ext.data.reader.Json'
+    ],
+
+    constructor: function(config) {
+        config = Ext.apply({
+            proxy: {
+                type: 'jsonp',
+                reader: 'json'
+            }
+        }, config);
+        this.callParent([config]);
+    }
+});
+
+
+Ext.define('Ext.data.JsonStore',  {
+    extend: 'Ext.data.Store',
+    alias: 'store.json',
+    requires: [
+        'Ext.data.proxy.Ajax',
+        'Ext.data.reader.Json',
+        'Ext.data.writer.Json'
+    ],
+
+    constructor: function(config) {
+        config = Ext.apply({
+            proxy: {
+                type  : 'ajax',
+                reader: 'json',
+                writer: 'json'
+            }
+        }, config);
+        this.callParent([config]);
+    }
+});
+
+
+Ext.define('Ext.data.NodeInterface', {
+    requires: ['Ext.data.Field'],
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    statics: {
+        
+        decorate: function(modelClass) {
+            var idName, idType;
+            
+            
+            if (typeof modelClass == 'string') {
+                modelClass = Ext.ModelManager.getModel(modelClass);
+            } else if (modelClass.isModel) {
+                modelClass = Ext.ModelManager.getModel(modelClass.modelName);
+            }
+            
+            
+            if (modelClass.prototype.isNode) {
+                return;
+            }
+
+            idName = modelClass.prototype.idProperty;
+            idField = modelClass.prototype.fields.get(idName);
+            idType = modelClass.prototype.fields.get(idName).type.type;
+            modelClass.override(this.getPrototypeBody());
+            this.applyFields(modelClass, [
+                {name: 'parentId',   type: idType,    defaultValue: null, useNull: idField.useNull},
+                {name: 'index',      type: 'int',     defaultValue: null, persist: false},
+                {name: 'depth',      type: 'int',     defaultValue: 0, persist: false},
+                {name: 'expanded',   type: 'bool',    defaultValue: false, persist: false},
+                {name: 'expandable', type: 'bool',    defaultValue: true, persist: false},
+                {name: 'checked',    type: 'auto',    defaultValue: null, persist: false},
+                {name: 'leaf',       type: 'bool',    defaultValue: false},
+                {name: 'cls',        type: 'string',  defaultValue: null, persist: false},
+                {name: 'iconCls',    type: 'string',  defaultValue: null, persist: false},
+                {name: 'icon',       type: 'string',  defaultValue: null, persist: false},
+                {name: 'root',       type: 'boolean', defaultValue: false, persist: false},
+                {name: 'isLast',     type: 'boolean', defaultValue: false, persist: false},
+                {name: 'isFirst',    type: 'boolean', defaultValue: false, persist: false},
+                {name: 'allowDrop',  type: 'boolean', defaultValue: true, persist: false},
+                {name: 'allowDrag',  type: 'boolean', defaultValue: true, persist: false},
+                {name: 'loaded',     type: 'boolean', defaultValue: false, persist: false},
+                {name: 'loading',    type: 'boolean', defaultValue: false, persist: false},
+                {name: 'href',       type: 'string',  defaultValue: null, persist: false},
+                {name: 'hrefTarget', type: 'string',  defaultValue: null, persist: false},
+                {name: 'qtip',       type: 'string',  defaultValue: null, persist: false},
+                {name: 'qtitle',     type: 'string',  defaultValue: null, persist: false},
+                {name: 'children',   type: 'auto',   defaultValue: null, persist: false}
+            ]);
+        },
+        
+        applyFields: function(modelClass, addFields) {
+            var modelPrototype = modelClass.prototype,
+                fields = modelPrototype.fields,
+                keys = fields.keys,
+                ln = addFields.length,
+                addField, i;
+
+            for (i = 0; i < ln; i++) {
+                addField = addFields[i];
+                if (!Ext.Array.contains(keys, addField.name)) {
+                    fields.add(new Ext.data.Field(addField));
+                }
+            }
+
+        },
+
+        getPrototypeBody: function() {
+            return {
+                
+                isNode: true,
+                
+                constructor: function() {
+                    var me = this;
+                    this.callParent(arguments);
+                    Ext.applyIf(me, {
+                        firstChild: null,
+                        lastChild: null,
+                        parentNode: null,
+                        previousSibling: null,
+                        nextSibling: null,
+                        childNodes: []
+                    });
+                    me.enableBubble([
+                        
+                        "append",
+
+                        
+                        "remove",
+
+                        
+                        "move",
+
+                        
+                        "insert",
+
+                        
+                        "beforeappend",
+
+                        
+                        "beforeremove",
+
+                        
+                        "beforemove",
+
+                         
+                        "beforeinsert",
+
+                        
+                        "expand",
+
+                        
+                        "collapse",
+
+                        
+                        "beforeexpand",
+
+                        
+                        "beforecollapse",
+
+                        
+                        "sort"
+                    ]);
+                    return me;
+                },
+                
+                createNode: function(node) {
+                    if (Ext.isObject(node) && !node.isModel) {
+                        node = Ext.ModelManager.create(node, this.modelName);
+                    }
+                    
+                    
+                    
+                    if (!node.childNodes) {
+                        Ext.applyIf(node, {
+                            firstChild: null,
+                            lastChild: null,
+                            parentNode: null,
+                            previousSibling: null,
+                            nextSibling: null,
+                            childNodes: []
+                        });
+                    }
+                    return node;
+                },
+
+                
+                isLeaf : function() {
+                    return this.get('leaf') === true;
+                },
+
+                
+                setFirstChild : function(node) {
+                    this.firstChild = node;
+                },
+
+                
+                setLastChild : function(node) {
+                    this.lastChild = node;
+                },
+
+                
+                updateInfo: function(commit) {
+                    var me = this,
+                        isRoot = me.isRoot(),
+                        parentNode = me.parentNode,
+                        isFirst = (!parentNode || isRoot ? true : parentNode.firstChild === me),
+                        isLast = (!parentNode || isRoot ? true : parentNode.lastChild === me),
+                        depth = 0,
+                        parent = me,
+                        children = me.childNodes,
+                        len = children.length,
+                        i = 0,
+                        phantom = me.phantom;
+
+                    while (parent.parentNode) {
+                        ++depth;
+                        parent = parent.parentNode;
+                    }
+
+                    me.beginEdit();
+                    me.set({
+                        isFirst: isFirst,
+                        isLast: isLast,
+                        depth: depth,
+                        index: parentNode ? parentNode.indexOf(me) : 0,
+                        parentId: parentNode ? parentNode.getId() : null
+                    });
+                    me.endEdit(true);
+                    if (commit) {
+                        me.commit();
+                        me.phantom = phantom;
+                    }
+
+                    for (i = 0; i < len; i++) {
+                        children[i].updateInfo(commit);
+                    }
+                },
+
+                
+                isLast : function() {
+                   return this.get('isLast');
+                },
+
+                
+                isFirst : function() {
+                   return this.get('isFirst');
+                },
+
+                
+                hasChildNodes : function() {
+                    return !this.isLeaf() && this.childNodes.length > 0;
+                },
+
+                
+                isExpandable : function() {
+                    var me = this;
+
+                    if (me.get('expandable')) {
+                        return !(me.isLeaf() || (me.isLoaded() && !me.hasChildNodes()));
+                    }
+                    return false;
+                },
+                
+                triggerUIUpdate: function(){
+                    
+                    
+                    this.afterEdit([]);    
+                },
+
+                
+                appendChild : function(node, suppressEvents, commit) {
+                    var me = this,
+                        i, ln,
+                        index,
+                        oldParent,
+                        ps;
+
+                    
+                    if (Ext.isArray(node)) {
+                        
+                        me.callStore('suspendAutoSync');
+                        for (i = 0, ln = node.length - 1; i < ln; i++) {
+                            me.appendChild(node[i]);
+                        }
+                        
+                        me.callStore('resumeAutoSync');
+                        me.appendChild(node[ln]);
+                    } else {
+                        
+                        node = me.createNode(node);
+
+                        if (suppressEvents !== true && (!me.hasListeners.beforeappend || me.fireEvent("beforeappend", me, node) === false)) {
+                            return false;
+                        }
+
+                        index = me.childNodes.length;
+                        oldParent = node.parentNode;
+
+                        
+                        if (oldParent) {
+                            if (suppressEvents !== true && (!me.hasListeners.beforeremove || node.fireEvent("beforemove", node, oldParent, me, index) === false)) {
+                                return false;
+                            }
+                            oldParent.removeChild(node, false, false, true);
+                        }
+
+                        index = me.childNodes.length;
+                        if (index === 0) {
+                            me.setFirstChild(node);
+                        }
+
+                        me.childNodes.push(node);
+                        node.parentNode = me;
+                        node.nextSibling = null;
+
+                        me.setLastChild(node);
+
+                        ps = me.childNodes[index - 1];
+                        if (ps) {
+                            node.previousSibling = ps;
+                            ps.nextSibling = node;
+                            ps.updateInfo(commit);
+                        } else {
+                            node.previousSibling = null;
+                        }
+
+                        node.updateInfo(commit);
+
+                        
+                        if (!me.isLoaded()) {
+                            me.set('loaded', true);
+                        } else if (me.childNodes.length === 1) {
+                            me.triggerUIUpdate();
+                        }
+
+                        if(!node.isLeaf() && node.phantom) {
+                            node.set('loaded', true);
+                        }
+
+                        if (suppressEvents !== true) {
+                            me.fireEvent("append", me, node, index);
+
+                            if (oldParent) {
+                                node.fireEvent("move", node, oldParent, me, index);
+                            }
+                        }
+
+                        return node;
+                    }
+                },
+
+                
+                getBubbleTarget: function() {
+                    return this.parentNode;
+                },
+
+                
+                removeChild : function(node, destroy, suppressEvents, isMove) {
+                    var me = this,
+                        index = me.indexOf(node),
+                        i, childCount;
+
+                    if (index == -1 || (suppressEvents !== true && (!me.hasListeners.beforeremove || me.fireEvent("beforeremove", me, node, !!isMove) === false))) {
+                        return false;
+                    }
+
+                    
+                    Ext.Array.erase(me.childNodes, index, 1);
+
+                    
+                    if (me.firstChild == node) {
+                        me.setFirstChild(node.nextSibling);
+                    }
+                    if (me.lastChild == node) {
+                        me.setLastChild(node.previousSibling);
+                    }
+
+                    
+                    if (node.previousSibling) {
+                        node.previousSibling.nextSibling = node.nextSibling;
+                    }
+                    if (node.nextSibling) {
+                        node.nextSibling.previousSibling = node.previousSibling;
+                    }
+
+                    
+                    for(i = index > 0 ? index - 1 : 0, childCount = me.childNodes.length; i < childCount; i++) {
+                        me.childNodes[i].updateInfo();
+                    }
+
+                    
+                    if (!me.childNodes.length) {
+                        me.triggerUIUpdate();
+                    }
+
+                    if (suppressEvents !== true) {
+                        if (me.hasListeners.remove) {
+                            me.fireEvent("remove", me, node, !!isMove);
+                        }
+                    }
+
+                    if (destroy) {
+                        node.destroy(true);
+                    } else {
+                        node.clear();
+                    }
+
+                    return node;
+                },
+
+                
+                copy: function(newId, deep) {
+                    var me = this,
+                        result = me.callOverridden(arguments),
+                        len = me.childNodes ? me.childNodes.length : 0,
+                        i;
+
+                    
+                    if (deep) {
+                        for (i = 0; i < len; i++) {
+                            result.appendChild(me.childNodes[i].copy(true));
+                        }
+                    }
+                    return result;
+                },
+
+                
+                clear : function(destroy) {
+                    var me = this;
+
+                    
+                    me.parentNode = me.previousSibling = me.nextSibling = null;
+                    if (destroy) {
+                        me.firstChild = me.lastChild = null;
+                    }
+                },
+
+                
+                destroy : function(silent) {
+                    
+                    var me      = this,
+                        options = me.destroyOptions,
+                        nodes   = me.childNodes,
+                        nLen    = nodes.length,
+                        n;
+
+                    if (silent === true) {
+                        me.clear(true);
+
+                        for (n = 0; n < nLen; n++) {
+                            nodes[n].destroy(true);
+                        }
+
+                        me.childNodes = null;
+                        delete me.destroyOptions;
+                        me.callOverridden([options]);
+                    } else {
+                        me.destroyOptions = silent;
+                        
+                        me.remove(true);
+                    }
+                },
+
+                
+                insertBefore : function(node, refNode, suppressEvents) {
+                    var me = this,
+                        index     = me.indexOf(refNode),
+                        oldParent = node.parentNode,
+                        refIndex  = index,
+                        childCount, ps, i;
+
+                    if (!refNode) { 
+                        return me.appendChild(node);
+                    }
+
+                    
+                    if (node == refNode) {
+                        return false;
+                    }
+
+                    
+                    node = me.createNode(node);
+
+                    if (suppressEvents !== true && (!me.hasListeners.beforeinsert || me.fireEvent("beforeinsert", me, node, refNode) === false)) {
+                        return false;
+                    }
+
+                    
+                    if (oldParent == me && me.indexOf(node) < index) {
+                        refIndex--;
+                    }
+
+                    
+                    if (oldParent) {
+                        if (suppressEvents !== true && (!me.hasListeners.beforeremove || node.fireEvent("beforemove", node, oldParent, me, index, refNode) === false)) {
+                            return false;
+                        }
+                        oldParent.removeChild(node, false, false, true);
+                    }
+
+                    if (refIndex === 0) {
+                        me.setFirstChild(node);
+                    }
+
+                    Ext.Array.splice(me.childNodes, refIndex, 0, node);
+                    node.parentNode = me;
+
+                    node.nextSibling = refNode;
+                    refNode.previousSibling = node;
+
+                    ps = me.childNodes[refIndex - 1];
+                    if (ps) {
+                        node.previousSibling = ps;
+                        ps.nextSibling = node;
+                    } else {
+                        node.previousSibling = null;
+                    }
+
+                    
+                    for(i = refIndex > 0 ? refIndex - 1 : 0, childCount = me.childNodes.length; i < childCount; i++) {
+                        me.childNodes[i].updateInfo();
+                    }
+
+                    if (!me.isLoaded()) {
+                        me.set('loaded', true);
+                    }
+                    
+                    else if (me.childNodes.length === 1) {
+                        me.triggerUIUpdate();
+                    }
+
+                    if(!node.isLeaf() && node.phantom) {
+                        node.set('loaded', true);
+                    }
+
+                    if (suppressEvents !== true) {
+                        if (me.hasListeners.insert) {
+                            me.fireEvent("insert", me, node, refNode);
+                        }
+
+                        if (oldParent && me.hasListeners.move) {
+                            node.fireEvent("move", node, oldParent, me, refIndex, refNode);
+                        }
+                    }
+
+                    return node;
+                },
+
+                
+                insertChild: function(index, node) {
+                    var sibling = this.childNodes[index];
+                    if (sibling) {
+                        return this.insertBefore(node, sibling);
+                    }
+                    else {
+                        return this.appendChild(node);
+                    }
+                },
+
+                
+                remove : function(destroy, suppressEvents) {
+                    var parentNode = this.parentNode;
+
+                    if (parentNode) {
+                        parentNode.removeChild(this, destroy, suppressEvents);
+                    }
+                    return this;
+                },
+
+                
+                removeAll : function(destroy, suppressEvents) {
+                    var cn = this.childNodes,
+                        n;
+
+                    while ((n = cn[0])) {
+                        this.removeChild(n, destroy, suppressEvents);
+                    }
+                    return this;
+                },
+
+                
+                getChildAt : function(index) {
+                    return this.childNodes[index];
+                },
+
+                
+                replaceChild : function(newChild, oldChild, suppressEvents) {
+                    var s = oldChild ? oldChild.nextSibling : null;
+
+                    this.removeChild(oldChild, false, suppressEvents);
+                    this.insertBefore(newChild, s, suppressEvents);
+                    return oldChild;
+                },
+
+                
+                indexOf : function(child) {
+                    return Ext.Array.indexOf(this.childNodes, child);
+                },
+                
+                
+                indexOfId: function(id) {
+                    var childNodes = this.childNodes,
+                        len = childNodes.length,
+                        i = 0;
+                        
+                    for (; i < len; ++i) {
+                        if (childNodes[i].getId() === id) {
+                            return i;
+                        }    
+                    }
+                    return -1;
+                },
+
+                
+                getPath: function(field, separator) {
+                    field = field || this.idProperty;
+                    separator = separator || '/';
+
+                    var path = [this.get(field)],
+                        parent = this.parentNode;
+
+                    while (parent) {
+                        path.unshift(parent.get(field));
+                        parent = parent.parentNode;
+                    }
+                    return separator + path.join(separator);
+                },
+
+                
+                getDepth : function() {
+                    return this.get('depth');
+                },
+
+                
+                bubble : function(fn, scope, args) {
+                    var p = this;
+                    while (p) {
+                        if (fn.apply(scope || p, args || [p]) === false) {
+                            break;
+                        }
+                        p = p.parentNode;
+                    }
+                },
+
+                cascade: function() {
+                    if (Ext.isDefined(Ext.global.console)) {
+                        Ext.global.console.warn('Ext.data.Node: cascade has been deprecated. Please use cascadeBy instead.');
+                    }
+                    return this.cascadeBy.apply(this, arguments);
+                },
+
+                
+                cascadeBy : function(fn, scope, args) {
+                    if (fn.apply(scope || this, args || [this]) !== false) {
+                        var childNodes = this.childNodes,
+                            length     = childNodes.length,
+                            i;
+
+                        for (i = 0; i < length; i++) {
+                            childNodes[i].cascadeBy(fn, scope, args);
+                        }
+                    }
+                },
+
+                
+                eachChild : function(fn, scope, args) {
+                    var childNodes = this.childNodes,
+                        length     = childNodes.length,
+                        i;
+
+                    for (i = 0; i < length; i++) {
+                        if (fn.apply(scope || this, args || [childNodes[i]]) === false) {
+                            break;
+                        }
+                    }
+                },
+
+                
+                findChild : function(attribute, value, deep) {
+                    return this.findChildBy(function() {
+                        return this.get(attribute) == value;
+                    }, null, deep);
+                },
+
+                
+                findChildBy : function(fn, scope, deep) {
+                    var cs = this.childNodes,
+                        len = cs.length,
+                        i = 0, n, res;
+
+                    for (; i < len; i++) {
+                        n = cs[i];
+                        if (fn.call(scope || n, n) === true) {
+                            return n;
+                        }
+                        else if (deep) {
+                            res = n.findChildBy(fn, scope, deep);
+                            if (res !== null) {
+                                return res;
+                            }
+                        }
+                    }
+
+                    return null;
+                },
+
+                
+                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;
+                },
+
+                
+                sort : function(sortFn, recursive, suppressEvent) {
+                    var cs  = this.childNodes,
+                        ln = cs.length,
+                        i, n;
+
+                    if (ln > 0) {
+                        Ext.Array.sort(cs, sortFn);
+                        for (i = 0; i < ln; i++) {
+                            n = cs[i];
+                            n.previousSibling = cs[i-1];
+                            n.nextSibling = cs[i+1];
+
+                            if (i === 0) {
+                                this.setFirstChild(n);
+                            }
+                            if (i == ln - 1) {
+                                this.setLastChild(n);
+                            }
+                            n.updateInfo();
+                            if (recursive && !n.isLeaf()) {
+                                n.sort(sortFn, true, true);
+                            }
+                        }
+
+                        if (suppressEvent !== true) {
+                            this.fireEvent('sort', this, cs);
+                        }
+                    }
+                },
+
+                
+                isExpanded: function() {
+                    return this.get('expanded');
+                },
+
+                
+                isLoaded: function() {
+                    return this.get('loaded');
+                },
+
+                
+                isLoading: function() {
+                    return this.get('loading');
+                },
+
+                
+                isRoot: function() {
+                    return !this.parentNode;
+                },
+
+                
+                isVisible: function() {
+                    var parent = this.parentNode;
+                    while (parent) {
+                        if (!parent.isExpanded()) {
+                            return false;
+                        }
+                        parent = parent.parentNode;
+                    }
+                    return true;
+                },
+
+                
+                expand: function(recursive, callback, scope) {
+                    var me = this;
+
+                    
+                    
+
+                    
+                    if (!me.isLeaf()) {
+                        
+                        if (me.isLoading()) {
+                            me.on('expand', function(){
+                                me.expand(recursive, callback, scope);
+                            }, me, {single: true});
+                        } else {
+                            
+                            if (!me.isExpanded()) {
+                                
+                                
+                                
+                                
+                                me.fireEvent('beforeexpand', me, function() {
+                                    me.set('expanded', true);
+                                    if (me.hasListeners.expand) {
+                                        me.fireEvent('expand', me, me.childNodes, false);
+                                    }
+
+                                    
+                                    if (recursive) {
+                                        me.expandChildren(true, callback, scope);
+                                    } else {
+                                        Ext.callback(callback, scope || me, [me.childNodes]);
+                                    }
+                                }, me);
+                            } else if (recursive) {
+                                
+                                me.expandChildren(true, callback, scope);
+                            } else {
+                                Ext.callback(callback, scope || me, [me.childNodes]);
+                            }
+                        }
+                    } else {
+                        
+                        Ext.callback(callback, scope || me); 
+                    }
+                },
+
+                
+                expandChildren: function(recursive, callback, scope) {
+                    var me = this,
+                        i = 0,
+                        nodes = me.childNodes,
+                        ln = nodes.length,
+                        node,
+                        expanding = 0;
+
+                    for (; i < ln; ++i) {
+                        node = nodes[i];
+                        if (!node.isLeaf()) {
+                            expanding++;
+                            nodes[i].expand(recursive, function () {
+                                expanding--;
+                                if (callback && !expanding) {
+                                    Ext.callback(callback, scope || me, [me.childNodes]);
+                                }
+                            });
+                        }
+                    }
+
+                    if (!expanding && callback) {
+                        Ext.callback(callback, scope || me, [me.childNodes]);                    }
+                },
+
+                
+                collapse: function(recursive, callback, scope) {
+                    var me = this;
+
+                    
+                    if (!me.isLeaf()) {
+                        
+                        if (!me.collapsing && me.isExpanded()) {
+                            me.fireEvent('beforecollapse', me, function() {
+                                me.set('expanded', false);
+                                if (me.hasListeners.collapse) {
+                                    me.fireEvent('collapse', me, me.childNodes, false);
+                                }
+
+                                
+                                if (recursive) {
+                                    me.collapseChildren(true, callback, scope);
+                                }
+                                else {
+                                    Ext.callback(callback, scope || me, [me.childNodes]);
+                                }
+                            }, me);
+                        }
+                        
+                        else if (recursive) {
+                            me.collapseChildren(true, callback, scope);
+                        } else {
+                            Ext.callback(callback, scope || me, [me.childNodes]);
+                        }
+                    }
+                    
+                    else {
+                        Ext.callback(callback, scope || me, [me.childNodes]);
+                    }
+                },
+
+                
+                collapseChildren: function(recursive, callback, scope) {
+                    var me = this,
+                        i = 0,
+                        nodes = me.childNodes,
+                        ln = nodes.length,
+                        node,
+                        collapsing = 0;
+
+                    for (; i < ln; ++i) {
+                        node = nodes[i];
+                        if (!node.isLeaf()) {
+                            collapsing++;
+                            nodes[i].collapse(recursive, function () {
+                                collapsing--;
+                                if (callback && !collapsing) {
+                                    Ext.callback(callback, scope || me, [me.childNodes]);
+                                }
+                            });
+                        }
+                    }
+
+                    if (!collapsing && callback) {
+                        Ext.callback(callback, scope || me, [me.childNodes]);
+                    }
+                }
+            };
+        }
+    }
+});
+
+
+Ext.define('Ext.data.NodeStore', {
+    extend: 'Ext.data.Store',
+    alias: 'store.node',
+    requires: ['Ext.data.NodeInterface'],
+
+    
+    node: null,
+
+    
+    recursive: false,
+    
+        
+    rootVisible: false,
+
+    
+
+    constructor: function(config) {
+        var me = this,
+            node;
+
+        config = config || {};
+        Ext.apply(me, config);
+
+
+        config.proxy = {type: 'proxy'};
+        me.callParent([config]);
+
+        node = me.node;
+        if (node) {
+            me.node = null;
+            me.setNode(node);
+        }
+    },
+
+    setNode: function(node) {
+        var me = this;
+        if (me.node && me.node != node) {
+            
+            me.mun(me.node, {
+                expand: me.onNodeExpand,
+                collapse: me.onNodeCollapse,
+                append: me.onNodeAppend,
+                insert: me.onNodeInsert,
+                remove: me.onNodeRemove,
+                sort: me.onNodeSort,
+                scope: me
+            });
+            me.node = null;
+        }
+
+        if (node) {
+            Ext.data.NodeInterface.decorate(node.self);
+            me.removeAll();
+            if (me.rootVisible) {
+                me.add(node);
+            } else if (!node.isExpanded() && me.treeStore.autoLoad !== false) {
+                node.expand();
+            }
+
+            me.mon(node, {
+                expand: me.onNodeExpand,
+                collapse: me.onNodeCollapse,
+                append: me.onNodeAppend,
+                insert: me.onNodeInsert,
+                remove: me.onNodeRemove,
+                sort: me.onNodeSort,
+                scope: me
+            });
+            me.node = node;
+            if (node.isExpanded() && node.isLoaded()) {
+                me.onNodeExpand(node, node.childNodes, true);
+            }
+        }
+    },
+
+    onNodeSort: function(node, childNodes) {
+        var me = this;
+
+        if ((me.indexOf(node) !== -1 || (node === me.node && !me.rootVisible) && node.isExpanded())) {
+            me.onNodeCollapse(node, childNodes, true);
+            me.onNodeExpand(node, childNodes, true);
+        }
+    },
+
+    onNodeExpand: function(parent, records, suppressEvent) {
+        var me = this,
+            insertIndex = me.indexOf(parent) + 1,
+            ln = records ? records.length : 0,
+            i, record;
+
+        if (!me.recursive && parent !== me.node) {
+            return;
+        }
+
+        if (parent !== this.node && !me.isVisible(parent)) {
+            return;
+        }
+
+        if (!suppressEvent && me.fireEvent('beforeexpand', parent, records, insertIndex) === false) {
+            return;
+        }
+
+        if (ln) {
+            me.insert(insertIndex, records);
+            for (i = 0; i < ln; i++) {
+                record = records[i];
+                if (record.isExpanded()) {
+                    if (record.isLoaded()) {
+                        
+                        me.onNodeExpand(record, record.childNodes, true);
+                    }
+                    else {
+                        record.set('expanded', false);
+                        record.expand();
+                    }
+                }
+            }
+        }
+
+        if (!suppressEvent) {
+            me.fireEvent('expand', parent, records);
+        }
+    },
+
+    onNodeCollapse: function(parent, records, suppressEvent) {
+        var me = this,
+            ln = records.length,
+            collapseIndex = me.indexOf(parent) + 1,
+            i, record;
+
+        if (!me.recursive && parent !== me.node) {
+            return;
+        }
+
+        if (!suppressEvent && me.fireEvent('beforecollapse', parent, records, collapseIndex) === false) {
+            return;
+        }
+
+        for (i = 0; i < ln; i++) {
+            record = records[i];
+            me.remove(record);
+            if (record.isExpanded()) {
+                me.onNodeCollapse(record, record.childNodes, true);
+            }
+        }
+
+        if (!suppressEvent) {
+            me.fireEvent('collapse', parent, records, collapseIndex);
+        }
+    },
+
+    onNodeAppend: function(parent, node, index) {
+        var me = this,
+            refNode, sibling;
+
+        if (me.isVisible(node)) {
+            if (index === 0) {
+                refNode = parent;
+            } else {
+                sibling = node.previousSibling;
+                while (sibling.isExpanded() && sibling.lastChild) {
+                    sibling = sibling.lastChild;
+                }
+                refNode = sibling;
+            }
+            me.insert(me.indexOf(refNode) + 1, node);
+            if (!node.isLeaf() && node.isExpanded()) {
+                if (node.isLoaded()) {
+                    
+                    me.onNodeExpand(node, node.childNodes, true);
+                }
+                else {
+                    node.set('expanded', false);
+                    node.expand();
+                }
+            }
+        }
+    },
+
+    onNodeInsert: function(parent, node, refNode) {
+        var me = this,
+            index = this.indexOf(refNode);
+
+        if (index != -1 && me.isVisible(node)) {
+            me.insert(index, node);
+            if (!node.isLeaf() && node.isExpanded()) {
+                if (node.isLoaded()) {
+                    
+                    me.onNodeExpand(node, node.childNodes, true);
+                }
+                else {
+                    node.set('expanded', false);
+                    node.expand();
+                }
+            }
+        }
+    },
+
+    onNodeRemove: function(parent, node, index) {
+        var me = this;
+        if (me.indexOf(node) != -1) {
+            if (!node.isLeaf() && node.isExpanded()) {
+                me.onNodeCollapse(node, node.childNodes, true);
+            }
+            me.remove(node);
+        }
+    },
+
+    isVisible: function(node) {
+        var parent = node.parentNode;
+        while (parent) {
+            if (parent === this.node && !this.rootVisible && parent.isExpanded()) {
+                return true;
+            }
+
+            if (this.indexOf(parent) === -1 || !parent.isExpanded()) {
+                return false;
+            }
+
+            parent = parent.parentNode;
+        }
+        return true;
+    }
+});
+
+
+Ext.define('Ext.data.Request', {
+    
+    action: undefined,
+    
+    
+    params: undefined,
+    
+    
+    method: 'GET',
+    
+    
+    url: undefined,
+
+    
+    constructor: function(config) {
+        Ext.apply(this, config);
+    }
+});
+
+
+Ext.define('Ext.data.SequentialIdGenerator', {
+    extend: 'Ext.data.IdGenerator',
+    alias: 'idgen.sequential',
+
+    constructor: function() {
+        var me = this;
+
+        me.callParent(arguments);
+
+        me.parts = [ me.prefix, ''];
+    },
+
+    
+    prefix: '',
+
+    
+    seed: 1,
+
+    
+    generate: function () {
+        var me = this,
+            parts = me.parts;
+
+        parts[1] = me.seed++;
+        return parts.join('');
+    }
+});
+
+
+Ext.define('Ext.data.Tree', {
+    alias: 'data.tree',
+
+    mixins: {
+        observable: "Ext.util.Observable"
+    },
+
+    
+    root: null,
+
+    
+    constructor: function(root) {
+        var me = this;
+
+        me.mixins.observable.constructor.call(me);
+
+        if (root) {
+            me.setRootNode(root);
+        }
+    },
+
+    
+    getRootNode : function() {
+        return this.root;
+    },
+
+    
+    setRootNode : function(node) {
+        var me = this;
+
+        me.root = node;
+
+        if (me.fireEvent('beforeappend', null, node) !== false) {
+            node.set('root', true);
+            node.updateInfo();
+            
+            node.commit();
+
+            node.on({
+                scope: me,
+                insert: me.onNodeInsert,
+                append: me.onNodeAppend,
+                remove: me.onNodeRemove
+            });
+
+            me.relayEvents(node, [
+                
+                "append",
+
+                
+                "remove",
+
+                
+                "move",
+
+                
+                "insert",
+
+                
+                "beforeappend",
+
+                
+                "beforeremove",
+
+                
+                "beforemove",
+
+                
+                "beforeinsert",
+
+                
+                "expand",
+
+                
+                "collapse",
+
+                
+                "beforeexpand",
+
+                
+                "beforecollapse" ,
+
+                
+                "sort",
+
+                
+                "rootchange"
+            ]);
+
+            me.nodeHash = {};
+            me.registerNode(node);
+            me.fireEvent('append', null, node);
+            me.fireEvent('rootchange', node);
+        }
+
+        return node;
+    },
+
+    
+    flatten: function(){
+        return Ext.Object.getValues(this.nodeHash);
+    },
+
+    
+    onNodeInsert: function(parent, node) {
+        this.registerNode(node, true);
+    },
+
+    
+    onNodeAppend: function(parent, node) {
+        this.registerNode(node, true);
+    },
+
+    
+    onNodeRemove: function(parent, node) {
+        this.unregisterNode(node, true);
+    },
+
+    
+    onNodeIdChanged: function(node, oldId, newId) {
+        var nodeHash = this.nodeHash;
+    
+        nodeHash[newId] = node;
+        delete nodeHash[oldId || node.internalId];
+    },
+
+    
+    getNodeById : function(id) {
+        return this.nodeHash[id];
+    },
+
+    
+    registerNode : function(node, includeChildren) {
+        var me = this;
+
+        me.nodeHash[node.getId() || node.internalId] = node;
+        node.on('idchanged', me.onNodeIdChanged, me);
+        if (includeChildren === true) {
+            node.eachChild(function(child){
+                me.registerNode(child, true);
+            });
+        }
+    },
+
+    
+    unregisterNode : function(node, includeChildren) {
+        delete this.nodeHash[node.getId() || node.internalId];
+        if (includeChildren === true) {
+            node.eachChild(function(child){
+                this.unregisterNode(child, true);
+            }, this);
+        }
+    },
+
+    
+    sort: function(sorterFn, recursive) {
+        this.getRootNode().sort(sorterFn, recursive);
+    },
+
+     
+    filter: function(filters, recursive) {
+        this.getRootNode().filter(filters, recursive);
+    }
+});
+
+
+Ext.define('Ext.data.TreeStore', {
+    extend: 'Ext.data.AbstractStore',
+    alias: 'store.tree',
+    requires: [
+        'Ext.util.Sorter',
+        'Ext.data.Tree',
+        'Ext.data.NodeInterface'
+    ],
+
+    
+
+    
+    clearOnLoad : true,
+
+    
+    clearRemovedOnLoad: true,
+
+    
+    nodeParam: 'node',
+
+    
+    defaultRootId: 'root',
+
+    
+    defaultRootProperty: 'children',
+    
+    
+    rootProperty: 'children',
+
+    
+    folderSort: false,
+
+    constructor: function(config) {
+        var me = this,
+            root,
+            fields,
+            defaultRoot;
+
+        config = Ext.apply({}, config);
+
+        
+        fields = config.fields || me.fields;
+        if (!fields) {
+            config.fields = [
+                {name: 'text', type: 'string'}
+            ];
+            defaultRoot = config.defaultRootProperty || me.defaultRootProperty;
+            if (defaultRoot !== me.defaultRootProperty) {
+                config.fields.push({
+                    name: defaultRoot,   
+                    type: 'auto',   
+                    defaultValue: null, 
+                    persist: false
+                });
+            }
+        }
+
+        me.callParent([config]);
+
+        
+        me.tree = new Ext.data.Tree();
+
+        me.relayEvents(me.tree, [
+            
+            "append",
+
+            
+            "remove",
+
+            
+            "move",
+
+            
+            "insert",
+
+            
+            "beforeappend",
+
+            
+            "beforeremove",
+
+            
+            "beforemove",
+
+            
+            "beforeinsert",
+
+            
+            "expand",
+
+            
+            "collapse",
+
+            
+            "beforeexpand",
+
+            
+            "beforecollapse",
+
+            
+            "sort",
+
+            
+            "rootchange"
+        ]);
+
+        me.tree.on({
+            scope: me,
+            remove: me.onNodeRemove,
+            
+            
+            beforeexpand: me.onBeforeNodeExpand,
+            beforecollapse: me.onBeforeNodeCollapse,
+            append: me.onNodeAdded,
+            insert: me.onNodeAdded,
+            sort: me.onNodeSort
+        });
+
+        me.onBeforeSort();
+
+        root = me.root;
+        if (root) {
+            delete me.root;
+            me.setRootNode(root);
+        }
+
+        if (Ext.isDefined(me.nodeParameter)) {
+            if (Ext.isDefined(Ext.global.console)) {
+                Ext.global.console.warn('Ext.data.TreeStore: nodeParameter has been deprecated. Please use nodeParam instead.');
+            }
+            me.nodeParam = me.nodeParameter;
+            delete me.nodeParameter;
+        }
+    },
+
+    
+    setProxy: function(proxy) {
+        var reader,
+            needsRoot;
+
+        if (proxy instanceof Ext.data.proxy.Proxy) {
+            
+            needsRoot = Ext.isEmpty(proxy.getReader().root);
+        } else if (Ext.isString(proxy)) {
+            
+            needsRoot = true;
+        } else {
+            
+            reader = proxy.reader;
+            needsRoot = !(reader && !Ext.isEmpty(reader.root));
+        }
+        proxy = this.callParent(arguments);
+        if (needsRoot) {
+            reader = proxy.getReader();
+            reader.root = this.defaultRootProperty;
+            
+            reader.buildExtractors(true);
+        }
+    },
+
+    
+    onBeforeSort: function() {
+        if (this.folderSort) {
+            this.sort({
+                property: 'leaf',
+                direction: 'ASC'
+            }, 'prepend', false);
+        }
+    },
+
+    
+    onBeforeNodeExpand: function(node, callback, scope) {
+        if (node.isLoaded()) {
+            Ext.callback(callback, scope || node, [node.childNodes]);
+        }
+        else if (node.isLoading()) {
+            this.on('load', function() {
+                Ext.callback(callback, scope || node, [node.childNodes]);
+            }, this, {single: true});
+        }
+        else {
+            this.read({
+                node: node,
+                callback: function() {
+                    Ext.callback(callback, scope || node, [node.childNodes]);
+                }
+            });
+        }
+    },
+
+    
+    getNewRecords: function() {
+        return Ext.Array.filter(this.tree.flatten(), this.filterNew);
+    },
+
+    
+    getUpdatedRecords: function() {
+        return Ext.Array.filter(this.tree.flatten(), this.filterUpdated);
+    },
+
+    
+    onBeforeNodeCollapse: function(node, callback, scope) {
+        callback.call(scope || node, node.childNodes);
+    },
+
+    onNodeRemove: function(parent, node, isMove) {
+        var me = this,
+            removed = me.removed;
+
+        if (!node.isReplace && Ext.Array.indexOf(removed, node) == -1) {
+            removed.push(node);
+        }
+
+        if (me.autoSync && !me.autoSyncSuspended && !isMove) {
+            me.sync();
+        }
+    },
+
+    onNodeAdded: function(parent, node) {
+        var me = this,
+            proxy = me.getProxy(),
+            reader = proxy.getReader(),
+            data = node.raw || node[node.persistenceProperty],
+            dataRoot;
+
+        Ext.Array.remove(me.removed, node);
+
+        if (!node.isLeaf()) {
+            dataRoot = reader.getRoot(data);
+            if (dataRoot) {
+                me.fillNode(node, reader.extractData(dataRoot));
+                delete data[reader.root];
+            }
+        }
+
+        if (me.autoSync && !me.autoSyncSuspended && (node.phantom || node.dirty)) {
+            me.sync();
+        }
+    },
+
+    onNodeSort: function() {
+        if(this.autoSync && !this.autoSyncSuspended) {
+            this.sync();
+        }
+    },
+
+    
+    setRootNode: function(root,  preventLoad) {
+        var me = this,
+            model = me.model,
+            idProperty = model.prototype.idProperty
+
+        root = root || {};
+        if (!root.isModel) {
+            
+            Ext.applyIf(root, {
+                id: me.defaultRootId,
+                text: 'Root',
+                allowDrag: false
+            });
+            if (root[idProperty] === undefined) {
+                root[idProperty] = me.defaultRootId;
+            }
+            Ext.data.NodeInterface.decorate(model);
+            root = Ext.ModelManager.create(root, model);
+        } else if (root.isModel && !root.isNode) {
+            Ext.data.NodeInterface.decorate(model);
+        }
+
+
+        
+        
+        me.getProxy().getReader().buildExtractors(true);
+
+        
+        me.tree.setRootNode(root);
+
+        
+        if (preventLoad !== true && !root.isLoaded() && (me.autoLoad === true || root.isExpanded())) {
+            me.load({
+                node: root
+            });
+        }
+
+        return root;
+    },
+
+    
+    getRootNode: function() {
+        return this.tree.getRootNode();
+    },
+
+    
+    getNodeById: function(id) {
+        return this.tree.getNodeById(id);
+    },
+    
+    
+    getById: function(id) {
+        return this.getNodeById(id);    
+    },
+
+    
+    load: function(options) {
+        options = options || {};
+        options.params = options.params || {};
+
+        var me = this,
+            node = options.node || me.tree.getRootNode();
+
+        
+        
+        if (!node) {
+            node = me.setRootNode({
+                expanded: true
+            }, true);
+        }
+
+        
+        options.id = node.getId();
+
+        if (me.clearOnLoad) {
+            if(me.clearRemovedOnLoad) {
+                
+                me.clearRemoved(node);
+            }
+            
+            me.tree.un('remove', me.onNodeRemove, me);
+            
+            node.removeAll(false);
+            
+            me.tree.on('remove', me.onNodeRemove, me);
+        }
+
+        Ext.applyIf(options, {
+            node: node
+        });
+        options.params[me.nodeParam] = node ? node.getId() : 'root';
+
+        if (node) {
+            node.set('loading', true);
+        }
+
+        return me.callParent([options]);
+    },
+
+    
+    clearRemoved: function(node) {
+        var me = this,
+            removed = me.removed,
+            id = node.getId(),
+            removedLength = removed.length,
+            i = removedLength,
+            recordsToClear = {},
+            newRemoved = [],
+            removedHash = {},
+            removedNode,
+            targetNode,
+            targetId;
+
+        if(node === me.getRootNode()) {
+            
+            me.removed = [];
+            return;
+        }
+
+        
+        for(; i--;) {
+            removedNode = removed[i];
+            removedHash[removedNode.getId()] = removedNode;
+        }
+
+        for(i = removedLength; i--;) {
+            removedNode = removed[i];
+            targetNode = removedNode;
+            while(targetNode && targetNode.getId() !== id) {
+                
+                targetId = targetNode.get('parentId');
+                targetNode = targetNode.parentNode || me.getNodeById(targetId) || removedHash[targetId];
+            }
+            if(targetNode) {
+                
+                recordsToClear[removedNode.getId()] = removedNode;
+            }
+        }
+
+        
+        for(i = 0; i < removedLength; i++) {
+            removedNode = removed[i];
+            if(!recordsToClear[removedNode.getId()]) {
+                newRemoved.push(removedNode);
+            }
+        }
+
+        me.removed = newRemoved;
+    },
+
+    
+    fillNode: function(node, newNodes) {
+        var me = this,
+            ln = newNodes ? newNodes.length : 0,
+            sorters = me.sorters,
+            i, sortCollection,
+            needsIndexSort = false,
+            performLocalSort = ln && me.sortOnLoad && !me.remoteSort && sorters && sorters.items && sorters.items.length,
+            node1, node2;
+
+        
+        for (i = 1; i < ln; i++) {
+            node1 = newNodes[i];
+            node2 = newNodes[i - 1];
+            needsIndexSort = node1[node1.persistenceProperty].index != node2[node2.persistenceProperty].index;
+            if (needsIndexSort) {
+                break;
+            }
+        }
+
+        
+        if (performLocalSort) {
+            
+            if (needsIndexSort) {
+                me.sorters.insert(0, me.indexSorter);
+            }
+            sortCollection = new Ext.util.MixedCollection();
+            sortCollection.addAll(newNodes);
+            sortCollection.sort(me.sorters.items);
+            newNodes = sortCollection.items;
+
+            
+            me.sorters.remove(me.indexSorter);
+        } else if (needsIndexSort) {
+            Ext.Array.sort(newNodes, me.sortByIndex);
+        }
+
+        node.set('loaded', true);
+        for (i = 0; i < ln; i++) {
+            node.appendChild(newNodes[i], undefined, true);
+        }
+
+        return newNodes;
+    },
+
+    
+    sortByIndex: function(node1, node2) {
+        return node1[node1.persistenceProperty].index - node2[node2.persistenceProperty].index;
+    },
+
+    
+    onProxyLoad: function(operation) {
+        var me = this,
+            successful = operation.wasSuccessful(),
+            records = operation.getRecords(),
+            node = operation.node;
+
+        me.loading = false;
+        node.set('loading', false);
+        if (successful) {
+            if (!me.clearOnLoad) {
+                records = me.cleanRecords(node, records);
+            }
+            records = me.fillNode(node, records);
+        }
+        
+        
+        
+        
+        me.fireEvent('read', me, operation.node, records, successful);
+        me.fireEvent('load', me, operation.node, records, successful);
+        
+        Ext.callback(operation.callback, operation.scope || me, [records, operation, successful]);
+    },
+    
+    onCreateRecords: function(records) {
+        this.callParent(arguments);
+        
+        var i = 0,
+            len = records.length,
+            tree = this.tree,
+            node;
+
+        for (; i < len; ++i) {
+            node = records[i];
+            tree.onNodeIdChanged(node, null, node.getId());
+        }
+        
+    },
+    
+    cleanRecords: function(node, records){
+        var nodeHash = {},
+            childNodes = node.childNodes,
+            i = 0,
+            len  = childNodes.length,
+            out = [],
+            rec;
+            
+        
+        for (; i < len; ++i) {
+            nodeHash[childNodes[i].getId()] = true;
+        }
+        
+        for (i = 0, len = records.length; i < len; ++i) {
+            rec = records[i];
+            if (!nodeHash[rec.getId()]) {
+                out.push(rec);    
+            }
+        }
+        
+        return out;
+    },
+
+    
+    removeAll: function() {
+        var root = this.getRootNode();
+        if (root) {
+            root.destroy(true);
+        }
+        this.fireEvent('clear', this);
+    },
+
+    
+    doSort: function(sorterFn) {
+        var me = this;
+        if (me.remoteSort) {
+            
+            me.load();
+        } else {
+            me.tree.sort(sorterFn, true);
+            me.fireEvent('datachanged', me);
+            me.fireEvent('refresh', me);
+        }
+        me.fireEvent('sort', me);
+    }
+}, function() {
+    var proto = this.prototype;
+    proto.indexSorter = new Ext.util.Sorter({
+        sorterFn: proto.sortByIndex
+    });
+});
+
+
+Ext.define('Ext.data.UuidGenerator', (function () {
+    var twoPow14 = Math.pow(2, 14),
+        twoPow16 = Math.pow(2, 16),
+        twoPow28 = Math.pow(2, 28),
+        twoPow32 = Math.pow(2, 32);
+
+    function toHex (value, length) {
+        var ret = value.toString(16);
+        if (ret.length > length) {
+            ret = ret.substring(ret.length - length); 
+        } else if (ret.length < length) {
+            ret = Ext.String.leftPad(ret, length, '0');
+        }
+        return ret;
+    }
+
+    function rand (lo, hi) {
+        var v = Math.random() * (hi - lo + 1);
+        return Math.floor(v) + lo;
+    }
+
+    function split (bignum) {
+        if (typeof(bignum) == 'number') {
+            var hi = Math.floor(bignum / twoPow32);
+            return {
+                lo: Math.floor(bignum - hi * twoPow32),
+                hi: hi
+            };
+        }
+        return bignum;
+    }
+
+    return {
+        extend: 'Ext.data.IdGenerator',
+
+        alias: 'idgen.uuid',
+
+        id: 'uuid', 
+
+        
+
+        
+
+        
+        version: 4,
+
+        constructor: function() {
+            var me = this;
+
+            me.callParent(arguments);
+
+            me.parts = [];
+            me.init();
+        },
+
+        generate: function () {
+            var me = this,
+                parts = me.parts,
+                ts = me.timestamp;
+
+            
+            parts[0] = toHex(ts.lo, 8);
+            parts[1] = toHex(ts.hi & 0xFFFF, 4);
+            parts[2] = toHex(((ts.hi >>> 16) & 0xFFF) | (me.version << 12), 4);
+            parts[3] = toHex(0x80 | ((me.clockSeq >>> 8) & 0x3F), 2) +
+                       toHex(me.clockSeq & 0xFF, 2);
+            parts[4] = toHex(me.salt.hi, 4) + toHex(me.salt.lo, 8);
+
+            if (me.version == 4) {
+                me.init(); 
+            } else {
+                
+                ++ts.lo;
+                if (ts.lo >= twoPow32) { 
+                    ts.lo = 0;
+                    ++ts.hi;
+                }
+            }
+
+            return parts.join('-').toLowerCase();
+        },
+
+        getRecId: function (rec) {
+            return rec.getId();
+        },
+
+        
+        init: function () {
+            var me = this,
+                salt, time;
+
+            if (me.version == 4) {
+                
+                
+                
+                
+                me.clockSeq = rand(0, twoPow14-1);
+
+                
+                salt = me.salt || (me.salt = {});
+                time = me.timestamp || (me.timestamp = {});
+
+                
+                salt.lo = rand(0, twoPow32-1);
+                salt.hi = rand(0, twoPow16-1);
+                time.lo = rand(0, twoPow32-1);
+                time.hi = rand(0, twoPow28-1);
+            } else {
+                
+                me.salt = split(me.salt);
+                me.timestamp = split(me.timestamp);
+
+                
+                
+                me.salt.hi |= 0x100;
+            }
+        },
+
+        
+        reconfigure: function (config) {
+            Ext.apply(this, config);
+            this.init();
+        }
+    };
+}()));
+
+
+Ext.define('Ext.data.reader.Xml', {
+    extend: 'Ext.data.reader.Reader',
+    alternateClassName: 'Ext.data.XmlReader',
+    alias : 'reader.xml',
+
+    
+
+    
+    createAccessor: function(expr) {
+        var me = this;
+
+        if (Ext.isEmpty(expr)) {
+            return Ext.emptyFn;
+        }
+
+        if (Ext.isFunction(expr)) {
+            return expr;
+        }
+
+        return function(root) {
+            return me.getNodeValue(Ext.DomQuery.selectNode(expr, root));
+        };
+    },
+
+    getNodeValue: function(node) {
+        if (node && node.firstChild) {
+            return node.firstChild.nodeValue;
+        }
+        return undefined;
+    },
+
+    
+    getResponseData: function(response) {
+        var xml = response.responseXML,
+            error,
+            msg;
+
+        if (!xml) {
+            msg = 'XML data not found in the response';               
+
+            error = new Ext.data.ResultSet({
+                total  : 0,
+                count  : 0,
+                records: [],
+                success: false,
+                message: msg
+            });
+
+            this.fireEvent('exception', this, response, error);
+
+            Ext.Logger.warn(msg);
+
+            return error;
+        }
+
+        return this.readRecords(xml);
+    },
+
+    
+    getData: function(data) {
+        return data.documentElement || data;
+    },
+
+    
+    getRoot: function(data) {
+        var nodeName = data.nodeName,
+            root     = this.root;
+
+        if (!root || (nodeName && nodeName == root)) {
+            return data;
+        } else if (Ext.DomQuery.isXml(data)) {
+            
+            
+            
+            return Ext.DomQuery.selectNode(root, data);
+        }
+    },
+
+    
+    extractData: function(root) {
+        var recordName = this.record;
+
+
+        if (recordName != root.nodeName) {
+            root = Ext.DomQuery.select(recordName, root);
+        } else {
+            root = [root];
+        }
+        return this.callParent([root]);
+    },
+
+    
+    getAssociatedDataRoot: function(data, associationName) {
+        return Ext.DomQuery.select(associationName, data)[0];
+    },
+
+    
+    readRecords: function(doc) {
+        
+        
+        if (Ext.isArray(doc)) {
+            doc = doc[0];
+        }
+
+        
+        this.xmlData = doc;
+        return this.callParent([doc]);
+    },
+
+    
+    createFieldAccessExpression: function(field, fieldVarName, dataName) {
+        var selector = field.mapping || field.name,
+            result;
+
+        if (typeof selector === 'function') {
+            result = fieldVarName + '.mapping(' + dataName + ', this)';
+        } else {
+            result = 'me.getNodeValue(Ext.DomQuery.selectNode("' + selector + '", ' + dataName + '))';
+        }
+        return result;
+    }
+});
+
+
+Ext.define('Ext.data.writer.Xml', {
+    
+    
+    
+    extend: 'Ext.data.writer.Writer',
+    alternateClassName: 'Ext.data.XmlWriter',
+    
+    alias: 'writer.xml',
+    
+    
+    
+    
+    documentRoot: 'xmlData',
+    
+    
+    defaultDocumentRoot: 'xmlData',
+
+    
+    header: '',
+
+    
+    record: 'record',
+
+    
+    writeRecords: function(request, data) {
+        var me = this,
+            xml = [],
+            i = 0,
+            len = data.length,
+            root = me.documentRoot,
+            record = me.record,
+            needsRoot = data.length !== 1,
+            item,
+            key;
+            
+        
+        xml.push(me.header || '');
+        
+        if (!root && needsRoot) {
+            root = me.defaultDocumentRoot;
+        }
+        
+        if (root) {
+            xml.push('<', root, '>');
+        }
+            
+        for (; i < len; ++i) {
+            item = data[i];
+            xml.push('<', record, '>');
+            for (key in item) {
+                if (item.hasOwnProperty(key)) {
+                    xml.push('<', key, '>', item[key], '</', key, '>');
+                }
+            }
+            xml.push('</', record, '>');
+        }
+        
+        if (root) {
+            xml.push('</', root, '>');
+        }
+            
+        request.xmlData = xml.join('');
+        return request;
+    }
+});
+
+
+Ext.define('Ext.data.XmlStore', {
+    extend: 'Ext.data.Store',
+    alias: 'store.xml',
+
+    requires: [
+        'Ext.data.proxy.Ajax',
+        'Ext.data.reader.Xml',
+        'Ext.data.writer.Xml'
+    ],
+    
+    constructor: function(config){
+        config = Ext.apply({
+            proxy: {
+                type: 'ajax',
+                reader: 'xml',
+                writer: 'xml'
+            }
+        }, config);
+
+        this.callParent([config]);
+    }
+});
+
+
+Ext.define('Ext.data.association.BelongsTo', {
+    extend: 'Ext.data.association.Association',
+    alternateClassName: 'Ext.data.BelongsToAssociation',
+    alias: 'association.belongsto',
+
+    
+
+    
+
+    
+
+    
+    constructor: function(config) {
+        this.callParent(arguments);
+
+        var me             = this,
+            ownerProto     = me.ownerModel.prototype,
+            associatedName = me.associatedName,
+            getterName     = me.getterName || 'get' + associatedName,
+            setterName     = me.setterName || 'set' + associatedName;
+
+        Ext.applyIf(me, {
+            name        : associatedName,
+            foreignKey  : associatedName.toLowerCase() + "_id",
+            instanceName: associatedName + 'BelongsToInstance',
+            associationKey: associatedName.toLowerCase()
+        });
+
+        ownerProto[getterName] = me.createGetter();
+        ownerProto[setterName] = me.createSetter();
+    },
+
+    
+    createSetter: function() {
+        var me = this,
+            foreignKey = me.foreignKey;
+
+        
+        return function(value, options, scope) {
+            
+            if (value && value.isModel) {
+                value = value.getId();
+            }
+            this.set(foreignKey, value);
+
+            if (Ext.isFunction(options)) {
+                options = {
+                    callback: options,
+                    scope: scope || this
+                };
+            }
+
+            if (Ext.isObject(options)) {
+                return this.save(options);
+            }
+        };
+    },
+
+    
+    createGetter: function() {
+        var me              = this,
+            associatedName  = me.associatedName,
+            associatedModel = me.associatedModel,
+            foreignKey      = me.foreignKey,
+            primaryKey      = me.primaryKey,
+            instanceName    = me.instanceName;
+
+        
+        return function(options, scope) {
+            options = options || {};
+
+            var model = this,
+                foreignKeyId = model.get(foreignKey),
+                success,
+                instance,
+                args;
+
+            if (options.reload === true || model[instanceName] === undefined) {
+                instance = Ext.ModelManager.create({}, associatedName);
+                instance.set(primaryKey, foreignKeyId);
+
+                if (typeof options == 'function') {
+                    options = {
+                        callback: options,
+                        scope: scope || model
+                    };
+                }
+                
+                
+                success = options.success;
+                options.success = function(rec){
+                    model[instanceName] = rec;
+                    if (success) {
+                        success.apply(this, arguments);
+                    }
+                };
+
+                associatedModel.load(foreignKeyId, options);
+                
+                model[instanceName] = instance;
+                return instance;
+            } else {
+                instance = model[instanceName];
+                args = [instance];
+                scope = scope || options.scope || model;
+
+                
+                
+                
+                Ext.callback(options, scope, args);
+                Ext.callback(options.success, scope, args);
+                Ext.callback(options.failure, scope, args);
+                Ext.callback(options.callback, scope, args);
+
+                return instance;
+            }
+        };
+    },
+
+    
+    read: function(record, reader, associationData){
+        record[this.instanceName] = reader.read([associationData]).records[0];
+    }
+});
+
+
+Ext.define('Ext.util.Inflector', {
+
+    
+
+    singleton: true,
+
+    
+
+    
+    plurals: [
+        [(/(quiz)$/i),                "$1zes"  ],
+        [(/^(ox)$/i),                 "$1en"   ],
+        [(/([m|l])ouse$/i),           "$1ice"  ],
+        [(/(matr|vert|ind)ix|ex$/i),  "$1ices" ],
+        [(/(x|ch|ss|sh)$/i),          "$1es"   ],
+        [(/([^aeiouy]|qu)y$/i),       "$1ies"  ],
+        [(/(hive)$/i),                "$1s"    ],
+        [(/(?:([^f])fe|([lr])f)$/i),  "$1$2ves"],
+        [(/sis$/i),                   "ses"    ],
+        [(/([ti])um$/i),              "$1a"    ],
+        [(/(buffal|tomat|potat)o$/i), "$1oes"  ],
+        [(/(bu)s$/i),                 "$1ses"  ],
+        [(/(alias|status|sex)$/i),    "$1es"   ],
+        [(/(octop|vir)us$/i),         "$1i"    ],
+        [(/(ax|test)is$/i),           "$1es"   ],
+        [(/^person$/),                "people" ],
+        [(/^man$/),                   "men"    ],
+        [(/^(child)$/),               "$1ren"  ],
+        [(/s$/i),                     "s"      ],
+        [(/$/),                       "s"      ]
+    ],
+
+    
+    singulars: [
+      [(/(quiz)zes$/i),                                                    "$1"     ],
+      [(/(matr)ices$/i),                                                   "$1ix"   ],
+      [(/(vert|ind)ices$/i),                                               "$1ex"   ],
+      [(/^(ox)en/i),                                                       "$1"     ],
+      [(/(alias|status)es$/i),                                             "$1"     ],
+      [(/(octop|vir)i$/i),                                                 "$1us"   ],
+      [(/(cris|ax|test)es$/i),                                             "$1is"   ],
+      [(/(shoe)s$/i),                                                      "$1"     ],
+      [(/(o)es$/i),                                                        "$1"     ],
+      [(/(bus)es$/i),                                                      "$1"     ],
+      [(/([m|l])ice$/i),                                                   "$1ouse" ],
+      [(/(x|ch|ss|sh)es$/i),                                               "$1"     ],
+      [(/(m)ovies$/i),                                                     "$1ovie" ],
+      [(/(s)eries$/i),                                                     "$1eries"],
+      [(/([^aeiouy]|qu)ies$/i),                                            "$1y"    ],
+      [(/([lr])ves$/i),                                                    "$1f"    ],
+      [(/(tive)s$/i),                                                      "$1"     ],
+      [(/(hive)s$/i),                                                      "$1"     ],
+      [(/([^f])ves$/i),                                                    "$1fe"   ],
+      [(/(^analy)ses$/i),                                                  "$1sis"  ],
+      [(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i), "$1$2sis"],
+      [(/([ti])a$/i),                                                      "$1um"   ],
+      [(/(n)ews$/i),                                                       "$1ews"  ],
+      [(/people$/i),                                                       "person" ],
+      [(/s$/i),                                                            ""       ]
+    ],
+
+    
+     uncountable: [
+        "sheep",
+        "fish",
+        "series",
+        "species",
+        "money",
+        "rice",
+        "information",
+        "equipment",
+        "grass",
+        "mud",
+        "offspring",
+        "deer",
+        "means"
+    ],
+
+    
+    singular: function(matcher, replacer) {
+        this.singulars.unshift([matcher, replacer]);
+    },
+
+    
+    plural: function(matcher, replacer) {
+        this.plurals.unshift([matcher, replacer]);
+    },
+
+    
+    clearSingulars: function() {
+        this.singulars = [];
+    },
+
+    
+    clearPlurals: function() {
+        this.plurals = [];
+    },
+
+    
+    isTransnumeral: function(word) {
+        return Ext.Array.indexOf(this.uncountable, word) != -1;
+    },
+
+    
+    pluralize: function(word) {
+        if (this.isTransnumeral(word)) {
+            return word;
+        }
+
+        var plurals = this.plurals,
+            length  = plurals.length,
+            tuple, regex, i;
+
+        for (i = 0; i < length; i++) {
+            tuple = plurals[i];
+            regex = tuple[0];
+
+            if (regex == word || (regex.test && regex.test(word))) {
+                return word.replace(regex, tuple[1]);
+            }
+        }
+
+        return word;
+    },
+
+    
+    singularize: function(word) {
+        if (this.isTransnumeral(word)) {
+            return word;
+        }
+
+        var singulars = this.singulars,
+            length    = singulars.length,
+            tuple, regex, i;
+
+        for (i = 0; i < length; i++) {
+            tuple = singulars[i];
+            regex = tuple[0];
+
+            if (regex == word || (regex.test && regex.test(word))) {
+                return word.replace(regex, tuple[1]);
+            }
+        }
+
+        return word;
+    },
+
+    
+    classify: function(word) {
+        return Ext.String.capitalize(this.singularize(word));
+    },
+
+    
+    ordinalize: function(number) {
+        var parsed = parseInt(number, 10),
+            mod10  = parsed % 10,
+            mod100 = parsed % 100;
+
+        
+        if (11 <= mod100 && mod100 <= 13) {
+            return number + "th";
+        } else {
+            switch(mod10) {
+                case 1 : return number + "st";
+                case 2 : return number + "nd";
+                case 3 : return number + "rd";
+                default: return number + "th";
+            }
+        }
+    }
+}, function() {
+    
+    var irregulars = {
+            alumnus: 'alumni',
+            cactus : 'cacti',
+            focus  : 'foci',
+            nucleus: 'nuclei',
+            radius: 'radii',
+            stimulus: 'stimuli',
+            ellipsis: 'ellipses',
+            paralysis: 'paralyses',
+            oasis: 'oases',
+            appendix: 'appendices',
+            index: 'indexes',
+            beau: 'beaux',
+            bureau: 'bureaux',
+            tableau: 'tableaux',
+            woman: 'women',
+            child: 'children',
+            man: 'men',
+            corpus:	'corpora',
+            criterion: 'criteria',
+            curriculum:	'curricula',
+            genus: 'genera',
+            memorandum:	'memoranda',
+            phenomenon:	'phenomena',
+            foot: 'feet',
+            goose: 'geese',
+            tooth: 'teeth',
+            antenna: 'antennae',
+            formula: 'formulae',
+            nebula: 'nebulae',
+            vertebra: 'vertebrae',
+            vita: 'vitae'
+        },
+        singular;
+
+    for (singular in irregulars) {
+        this.plural(singular, irregulars[singular]);
+        this.singular(irregulars[singular], singular);
+    }
+});
+
+
+Ext.define('Ext.data.association.HasMany', {
+    extend: 'Ext.data.association.Association',
+    alternateClassName: 'Ext.data.HasManyAssociation',
+    requires: ['Ext.util.Inflector'],
+
+    alias: 'association.hasmany',
+
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    constructor: function(config) {
+        var me = this,
+            ownerProto,
+            name;
+            
+        me.callParent(arguments);
+        
+        me.name = me.name || Ext.util.Inflector.pluralize(me.associatedName.toLowerCase());
+        
+        ownerProto = me.ownerModel.prototype;
+        name = me.name;
+        
+        Ext.applyIf(me, {
+            storeName : name + "Store",
+            foreignKey: me.ownerName.toLowerCase() + "_id"
+        });
+        
+        ownerProto[name] = me.createStore();
+    },
+    
+    
+    createStore: function() {
+        var that            = this,
+            associatedModel = that.associatedModel,
+            storeName       = that.storeName,
+            foreignKey      = that.foreignKey,
+            primaryKey      = that.primaryKey,
+            filterProperty  = that.filterProperty,
+            autoLoad        = that.autoLoad,
+            storeConfig     = that.storeConfig || {};
+        
+        return function() {
+            var me = this,
+                config, filter,
+                modelDefaults = {};
+                
+            if (me[storeName] === undefined) {
+                if (filterProperty) {
+                    filter = {
+                        property  : filterProperty,
+                        value     : me.get(filterProperty),
+                        exactMatch: true
+                    };
+                } else {
+                    filter = {
+                        property  : foreignKey,
+                        value     : me.get(primaryKey),
+                        exactMatch: true
+                    };
+                }
+                
+                modelDefaults[foreignKey] = me.get(primaryKey);
+                
+                config = Ext.apply({}, storeConfig, {
+                    model        : associatedModel,
+                    filters      : [filter],
+                    remoteFilter : false,
+                    modelDefaults: modelDefaults
+                });
+                
+                me[storeName] = Ext.data.AbstractStore.create(config);
+                if (autoLoad) {
+                    me[storeName].load();
+                }
+            }
+            
+            return me[storeName];
+        };
+    },
+    
+    
+    read: function(record, reader, associationData){
+        var store = record[this.name](),
+            inverse,
+            items, iLen, i;
+    
+        store.add(reader.read(associationData).records);
+    
+        
+        
+        inverse = this.associatedModel.prototype.associations.findBy(function(assoc){
+            return assoc.type === 'belongsTo' && assoc.associatedName === record.$className;
+        });
+    
+        
+        if (inverse) {
+            items = store.data.items;
+            iLen  = items.length;
+
+            for (i = 0; i < iLen; i++) {
+                items[i][inverse.instanceName] = record;
+            }
+        }
+    }
+});
+
+
+Ext.define('Ext.data.association.HasOne', {
+    extend: 'Ext.data.association.Association',
+    alternateClassName: 'Ext.data.HasOneAssociation',
+
+    alias: 'association.hasone',
+    
+    
+
+    
+
+    
+
+    
+    
+    constructor: function(config) {
+        this.callParent(arguments);
+
+        var me             = this,
+            ownerProto     = me.ownerModel.prototype,
+            associatedName = me.associatedName,
+            getterName     = me.getterName || 'get' + associatedName,
+            setterName     = me.setterName || 'set' + associatedName;
+
+        Ext.applyIf(me, {
+            name        : associatedName,
+            foreignKey  : associatedName.toLowerCase() + "_id",
+            instanceName: associatedName + 'HasOneInstance',
+            associationKey: associatedName.toLowerCase()
+        });
+
+        ownerProto[getterName] = me.createGetter();
+        ownerProto[setterName] = me.createSetter();
+    },
+    
+    
+    createSetter: function() {
+        var me              = this,
+            ownerModel      = me.ownerModel,
+            foreignKey      = me.foreignKey;
+
+        
+        return function(value, options, scope) {
+            if (value && value.isModel) {
+                value = value.getId();
+            }
+            
+            this.set(foreignKey, value);
+
+            if (Ext.isFunction(options)) {
+                options = {
+                    callback: options,
+                    scope: scope || this
+                };
+            }
+
+            if (Ext.isObject(options)) {
+                return this.save(options);
+            }
+        };
+    },
+
+    
+    createGetter: function() {
+        var me              = this,
+            ownerModel      = me.ownerModel,
+            associatedName  = me.associatedName,
+            associatedModel = me.associatedModel,
+            foreignKey      = me.foreignKey,
+            primaryKey      = me.primaryKey,
+            instanceName    = me.instanceName;
+
+        
+        return function(options, scope) {
+            options = options || {};
+
+            var model = this,
+                foreignKeyId = model.get(foreignKey),
+                success,
+                instance,
+                args;
+
+            if (options.reload === true || model[instanceName] === undefined) {
+                instance = Ext.ModelManager.create({}, associatedName);
+                instance.set(primaryKey, foreignKeyId);
+
+                if (typeof options == 'function') {
+                    options = {
+                        callback: options,
+                        scope: scope || model
+                    };
+                }
+                
+                
+                success = options.success;
+                options.success = function(rec){
+                    model[instanceName] = rec;
+                    if (success) {
+                        success.apply(this, arguments);
+                    }
+                };
+
+                associatedModel.load(foreignKeyId, options);
+                
+                model[instanceName] = instance;
+                return instance;
+            } else {
+                instance = model[instanceName];
+                args = [instance];
+                scope = scope || options.scope || model;
+
+                
+                
+                
+                Ext.callback(options, scope, args);
+                Ext.callback(options.success, scope, args);
+                Ext.callback(options.failure, scope, args);
+                Ext.callback(options.callback, scope, args);
+
+                return instance;
+            }
+        };
+    },
+    
+    
+    read: function(record, reader, associationData){
+        var inverse = this.associatedModel.prototype.associations.findBy(function(assoc){
+            return assoc.type === 'belongsTo' && assoc.associatedName === record.$className;
+        }), newRecord = reader.read([associationData]).records[0];
+        
+        record[this.instanceName] = newRecord;
+    
+        
+        if (inverse) {
+            newRecord[inverse.instanceName] = record;
+        }
+    }
+});
+
+
+Ext.define('Ext.data.proxy.WebStorage', {
+    extend: 'Ext.data.proxy.Client',
+    alternateClassName: 'Ext.data.WebStorageProxy',
+    requires: [
+        'Ext.data.SequentialIdGenerator'
+    ],
+
+    
+    id: undefined,
+
+    
+    constructor: function(config) {
+        this.callParent(arguments);
+
+        
+        this.cache = {};
+
+
+        
+        this.id = this.id || (this.store ? this.store.storeId : undefined);
+
+
+        this.initialize();
+    },
+
+    
+    create: function(operation, callback, scope) {
+        var me = this,
+            records = operation.records,
+            length = records.length,
+            ids = me.getIds(),
+            id, record, i;
+
+        operation.setStarted();
+
+        if(me.isHierarchical === undefined) {
+            
+            
+            me.isHierarchical = !!records[0].isNode;
+            if(me.isHierarchical) {
+                me.getStorageObject().setItem(me.getTreeKey(), true);
+            }
+        }
+
+        for (i = 0; i < length; i++) {
+            record = records[i];
+
+            if (record.phantom) {
+                record.phantom = false;
+                id = me.getNextId();
+            } else {
+                id = record.getId();
+            }
+
+            me.setRecord(record, id);
+            record.commit();
+            ids.push(id);
+        }
+
+        me.setIds(ids);
+
+        operation.setCompleted();
+        operation.setSuccessful();
+
+        if (typeof callback == 'function') {
+            callback.call(scope || me, operation);
+        }
+    },
+
+    
+    read: function(operation, callback, scope) {
+        
+
+        var me = this,
+            records = [],
+            i = 0,
+            success = true,
+            Model = me.model,
+            ids, length, record, data, id;
+
+        operation.setStarted();
+
+        if(me.isHierarchical) {
+            records = me.getTreeData();
+        } else {
+            ids = me.getIds();
+            length = ids.length;
+            id = operation.id;
+            
+            if (id) {
+                data = me.getRecord(id);
+                if (data !== null) {
+                    record = new Model(data, id, data);
+                }
+
+                if (record) {
+                    records.push(record);
+                } else {
+                    success = false;
+                }
+            } else {
+                for (; i < length; i++) {
+                    id = ids[i];
+                    data = me.getRecord(id);
+                    records.push(new Model(data, id, data));
+                }
+            }
+
+        }
+
+        if(success) {
+            operation.setSuccessful();
+        }
+        operation.setCompleted();
+
+        operation.resultSet = Ext.create('Ext.data.ResultSet', {
+            records: records,
+            total  : records.length,
+            loaded : true
+        });
+
+        if (typeof callback == 'function') {
+            callback.call(scope || me, operation);
+        }
+    },
+
+    
+    update: function(operation, callback, scope) {
+        var records = operation.records,
+            length  = records.length,
+            ids     = this.getIds(),
+            record, id, i;
+
+        operation.setStarted();
+
+        for (i = 0; i < length; i++) {
+            record = records[i];
+            this.setRecord(record);
+            record.commit();
+
+            
+            
+            id = record.getId();
+            if (id !== undefined && Ext.Array.indexOf(ids, id) == -1) {
+                ids.push(id);
+            }
+        }
+        this.setIds(ids);
+
+        operation.setCompleted();
+        operation.setSuccessful();
+
+        if (typeof callback == 'function') {
+            callback.call(scope || this, operation);
+        }
+    },
+
+    
+    destroy: function(operation, callback, scope) {
+        var me = this,
+            records = operation.records,
+            ids = me.getIds(),
+            idLength = ids.length,
+            newIds = [],
+            removedHash = {},
+            i = records.length,
+            id;
+
+        operation.setStarted();
+
+        for (; i--;) {
+            Ext.apply(removedHash, me.removeRecord(records[i]));
+        }
+
+        for(i = 0; i < idLength; i++) {
+            id = ids[i];
+            if(!removedHash[id]) {
+                newIds.push(id);
+            }
+        }
+
+        me.setIds(newIds);
+
+        operation.setCompleted();
+        operation.setSuccessful();
+
+        if (typeof callback == 'function') {
+            callback.call(scope || me, operation);
+        }
+    },
+
+    
+    getRecord: function(id) {
+        var me = this,
+            cache = me.cache,
+            data = !cache[id] ? Ext.decode(me.getStorageObject().getItem(me.getRecordKey(id))) : cache[id];
+
+        if(!data) {
+            return null;
+        }
+
+        cache[id] = data;
+        data[me.model.prototype.idProperty] = id;
+
+        return data;
+    },
+
+    
+    setRecord: function(record, id) {
+        if (id) {
+            record.setId(id);
+        } else {
+            id = record.getId();
+        }
+
+        var me = this,
+            rawData = record.data,
+            data    = {},
+            model   = me.model,
+            fields  = model.prototype.fields.items,
+            length  = fields.length,
+            i = 0,
+            field, name, obj, key;
+
+        for (; i < length; i++) {
+            field = fields[i];
+            name  = field.name;
+
+            if(field.persist) {
+                data[name] = rawData[name];
+            }
+        }
+
+        
+        delete data[me.model.prototype.idProperty];
+
+        
+        if(record.isNode && record.get('depth') === 1) {
+            delete data.parentId;
+        }
+
+        obj = me.getStorageObject();
+        key = me.getRecordKey(id);
+
+        
+        me.cache[id] = data;
+
+        
+        obj.removeItem(key);
+        obj.setItem(key, Ext.encode(data));
+    },
+
+    
+    removeRecord: function(record) {
+        var me = this,
+            id = record.getId(),
+            records = {},
+            i, childNodes;
+
+        records[id] = record;
+        me.getStorageObject().removeItem(me.getRecordKey(id));
+        delete me.cache[id];
+
+        if(record.childNodes) {
+            childNodes = record.childNodes;
+            for(i = childNodes.length; i--;) {
+                Ext.apply(records, me.removeRecord(childNodes[i]));
+            }
+        }
+
+        return records;
+    },
+
+    
+    getRecordKey: function(id) {
+        if (id.isModel) {
+            id = id.getId();
+        }
+
+        return Ext.String.format("{0}-{1}", this.id, id);
+    },
+
+    
+    getRecordCounterKey: function() {
+        return Ext.String.format("{0}-counter", this.id);
+    },
+
+    
+    getTreeKey: function() {
+        return Ext.String.format("{0}-tree", this.id);
+    },
+
+    
+    getIds: function() {
+        var me = this,
+            ids = (me.getStorageObject().getItem(me.id) || "").split(","),
+            model = me.model,
+            length = ids.length,
+            isString = model.prototype.fields.get(model.prototype.idProperty).type.type === 'string',
+            i;
+
+        if (length == 1 && ids[0] === "") {
+            ids = [];
+        } else {
+            for (i = 0; i < length; i++) {
+                ids[i] = isString ? ids[i] : +ids[i];
+            }
+        }
+
+        return ids;
+    },
+
+    
+    setIds: function(ids) {
+        var obj = this.getStorageObject(),
+            str = ids.join(",");
+
+        obj.removeItem(this.id);
+
+        if (!Ext.isEmpty(str)) {
+            obj.setItem(this.id, str);
+        }
+    },
+
+    
+    getNextId: function() {
+        var me = this,
+            obj = me.getStorageObject(),
+            key = me.getRecordCounterKey(),
+            model = me.model,
+            isString = model.prototype.fields.get(model.prototype.idProperty).type.type === 'string',
+            id;
+
+        id = me.idGenerator.generate();
+
+        obj.setItem(key, id);
+
+        if(!isString) {
+            id = +id;
+        }
+
+        return id;
+    },
+
+    
+    getTreeData: function() {
+        var me = this,
+            ids = me.getIds(),
+            length = ids.length,
+            records = [],
+            recordHash = {},
+            root = [],
+            i = 0,
+            Model = me.model,
+            idProperty = Model.prototype.idProperty,
+            rootLength, record, parent, parentId, children, id;
+
+        for(; i < length; i++) {
+            id = ids[i];
+            
+            record = me.getRecord(id);
+            
+            records.push(record);
+            
+            recordHash[id] = record;
+            if(!record.parentId) {
+                
+                root.push(record);
+            }
+        }
+
+        rootLength = root.length;
+
+        
+        Ext.Array.sort(records, me.sortByParentId);
+
+        
+        for(i = rootLength; i < length; i++) {
+            record = records[i];
+            parentId = record.parentId;
+            if(!parent || parent[idProperty] !== parentId) {
+                
+                parent = recordHash[parentId];
+                parent.children = children = [];
+            }
+
+            
+            children.push(record);
+        }
+
+        for(i = length; i--;) {
+            record = records[i];
+            if(!record.children && !record.leaf) {
+                
+                record.loaded = true;
+            }
+        }
+
+        
+        for(i = rootLength; i--;) {
+            record = root[i];
+            root[i] = new Model(record, record[idProperty], record);
+        }
+
+        return root;
+    },
+
+    
+    sortByParentId: function(node1, node2) {
+        return (node1.parentId || 0) - (node2.parentId || 0);
+    },
+
+    
+    initialize: function() {
+        var me = this,
+            storageObject = me.getStorageObject(),
+            lastId = +storageObject.getItem(me.getRecordCounterKey());
+
+        storageObject.setItem(me.id, storageObject.getItem(me.id) || "");
+        if(storageObject.getItem(me.getTreeKey())) {
+            me.isHierarchical = true;
+        }
+
+        me.idGenerator = new Ext.data.SequentialIdGenerator({
+            seed: lastId ? lastId + 1 : 1
+        });
+    },
+
+    
+    clear: function() {
+        var me = this,
+            obj = me.getStorageObject(),
+            ids = me.getIds(),
+            len = ids.length,
+            i;
+
+        
+        for (i = 0; i < len; i++) {
+            obj.removeItem(me.getRecordKey(ids[i]));
+        }
+
+        
+        obj.removeItem(me.getRecordCounterKey());
+        obj.removeItem(me.getTreeKey());
+        obj.removeItem(me.id);
+
+        
+        me.cache = {};
+    },
+
+    
+    getStorageObject: function() {
+    }
+});
+
+
+Ext.define('Ext.data.proxy.LocalStorage', {
+    extend: 'Ext.data.proxy.WebStorage',
+    alias: 'proxy.localstorage',
+    alternateClassName: 'Ext.data.LocalStorageProxy',
+    
+    
+    getStorageObject: function() {
+        return window.localStorage;
+    }
+});
+
+
+Ext.define('Ext.data.proxy.Rest', {
+    extend: 'Ext.data.proxy.Ajax',
+    alternateClassName: 'Ext.data.RestProxy',
+    alias : 'proxy.rest',
+    
+    
+    appendId: true,
+    
+    
+    
+    
+    batchActions: false,
+    
+    
+    buildUrl: function(request) {
+        var me        = this,
+            operation = request.operation,
+            records   = operation.records || [],
+            record    = records[0],
+            format    = me.format,
+            url       = me.getUrl(request),
+            id        = record ? record.getId() : operation.id;
+        
+        if (me.appendId && id) {
+            if (!url.match(/\/$/)) {
+                url += '/';
+            }
+            
+            url += id;
+        }
+        
+        if (format) {
+            if (!url.match(/\.$/)) {
+                url += '.';
+            }
+            
+            url += format;
+        }
+        
+        request.url = url;
+        
+        return me.callParent(arguments);
+    }
+}, function() {
+    Ext.apply(this.prototype, {
+        
+        actionMethods: {
+            create : 'POST',
+            read   : 'GET',
+            update : 'PUT',
+            destroy: 'DELETE'
+        }
+    });
+});
+
+
+Ext.define('Ext.data.proxy.SessionStorage', {
+    extend: 'Ext.data.proxy.WebStorage',
+    alias: 'proxy.sessionstorage',
+    alternateClassName: 'Ext.data.SessionStorageProxy',
+    
+    
+    getStorageObject: function() {
+        return window.sessionStorage;
+    }
+});
+
+
+
+
+
+Ext.define('Ext.dd.DDTarget', {
+    extend: 'Ext.dd.DragDrop',
+
+    
+    constructor: function(id, sGroup, config) {
+        if (id) {
+            this.initTarget(id, sGroup, config);
+        }
+    },
+
+    
+    getDragEl: Ext.emptyFn,
+    
+    isValidHandleChild: Ext.emptyFn,
+    
+    startDrag: Ext.emptyFn,
+    
+    endDrag: Ext.emptyFn,
+    
+    onDrag: Ext.emptyFn,
+    
+    onDragDrop: Ext.emptyFn,
+    
+    onDragEnter: Ext.emptyFn,
+    
+    onDragOut: Ext.emptyFn,
+    
+    onDragOver: Ext.emptyFn,
+    
+    onInvalidDrop: Ext.emptyFn,
+    
+    onMouseDown: Ext.emptyFn,
+    
+    onMouseUp: Ext.emptyFn,
+    
+    setXConstraint: Ext.emptyFn,
+    
+    setYConstraint: Ext.emptyFn,
+    
+    resetConstraints: Ext.emptyFn,
+    
+    clearConstraints: Ext.emptyFn,
+    
+    clearTicks: Ext.emptyFn,
+    
+    setInitPosition: Ext.emptyFn,
+    
+    setDragElId: Ext.emptyFn,
+    
+    setHandleElId: Ext.emptyFn,
+    
+    setOuterHandleElId: Ext.emptyFn,
+    
+    addInvalidHandleClass: Ext.emptyFn,
+    
+    addInvalidHandleId: Ext.emptyFn,
+    
+    addInvalidHandleType: Ext.emptyFn,
+    
+    removeInvalidHandleClass: Ext.emptyFn,
+    
+    removeInvalidHandleId: Ext.emptyFn,
+    
+    removeInvalidHandleType: Ext.emptyFn,
+
+    toString: function() {
+        return ("DDTarget " + this.id);
+    }
+});
+
+
+Ext.define('Ext.dd.DragTracker', {
+
+    uses: ['Ext.util.Region'],
+
+    mixins: {
+        observable: 'Ext.util.Observable'
+    },
+
+    
+    active: false,
+
+    
+
+    
+    trackOver: false,
+
+    
+
+    
+
+    
+    tolerance: 5,
+
+    
+    autoStart: false,
+
+    
+
+    
+
+    
+
+    constructor : function(config){
+        var me = this;
+        Ext.apply(me, config);
+        me.addEvents(
+            
+            'mouseover',
+
+            
+            'mouseout',
+
+            
+            'mousedown',
+
+            
+            'mouseup',
+
+            
+            'mousemove',
+
+            
+            'beforedragstart',
+
+            
+            'dragstart',
+
+            
+            'dragend',
+
+            
+            'drag'
+        );
+
+        me.dragRegion = new Ext.util.Region(0,0,0,0);
+
+        if (me.el) {
+            me.initEl(me.el);
+        }
+
+        
+        me.mixins.observable.constructor.call(me);
+        if (me.disabled) {
+            me.disable();
+        }
+
+    },
+
+    
+    initEl: function(el) {
+        var me = this;
+        
+        me.el = Ext.get(el);
+
+        
+        me.handle = Ext.get(me.delegate);
+
+        
+        me.delegate = me.handle ? undefined : me.delegate;
+
+        if (!me.handle) {
+            me.handle = me.el;
+        }
+
+        
+        
+        me.mon(me.handle, {
+            mousedown: me.onMouseDown,
+            delegate: me.delegate,
+            scope: me
+        });
+
+        
+        
+        
+        if (me.trackOver || me.overCls) {
+            me.mon(me.handle, {
+                mouseover: me.onMouseOver,
+                mouseout: me.onMouseOut,
+                delegate: me.delegate,
+                scope: me
+            });
+        }
+    },
+
+    disable: function() {
+        this.disabled = true;
+    },
+
+    enable: function() {
+        this.disabled = false;
+    },
+
+    destroy : function() {
+        this.clearListeners();
+        delete this.el;
+    },
+
+    
+    
+    onMouseOver: function(e, target) {
+        var me = this;
+        if (!me.disabled) {
+            if (Ext.EventManager.contains(e) || me.delegate) {
+                me.mouseIsOut = false;
+                if (me.overCls) {
+                    me.el.addCls(me.overCls);
+                }
+                me.fireEvent('mouseover', me, e, me.delegate ? e.getTarget(me.delegate, target) : me.handle);
+            }
+        }
+    },
+
+    
+    
+    onMouseOut: function(e) {
+        var me = this;
+        
+        if (me.mouseIsDown) {
+            me.mouseIsOut = true;
+        } else {
+            if (me.overCls) {
+                me.el.removeCls(me.overCls);
+            }
+            me.fireEvent('mouseout', me, e);
+        }
+    },
+
+    onMouseDown: function(e, target){
+        var me = this,
+            el;
+        
+        
+        if (me.disabled ||e.dragTracked) {
+            return;
+        }
+
+        
+        me.dragTarget = me.delegate ? target : me.handle.dom;
+        me.startXY = me.lastXY = e.getXY();
+        me.startRegion = Ext.fly(me.dragTarget).getRegion();
+
+        if (me.fireEvent('mousedown', me, e) === false ||
+            me.fireEvent('beforedragstart', me, e) === false ||
+            me.onBeforeStart(e) === false) {
+            return;
+        }
+
+        
+        
+        me.mouseIsDown = true;
+
+        
+        e.dragTracked = true;
+        
+        
+        el = me.el.dom;
+        if (Ext.isIE && el.setCapture) {
+            el.setCapture();
+        }
+
+        if (me.preventDefault !== false) {
+            e.preventDefault();
+        }
+        Ext.getDoc().on({
+            scope: me,
+            mouseup: me.onMouseUp,
+            mousemove: me.onMouseMove,
+            selectstart: me.stopSelect
+        });
+        if (me.autoStart) {
+            me.timer =  Ext.defer(me.triggerStart, me.autoStart === true ? 1000 : me.autoStart, me, [e]);
+        }
+    },
+
+    onMouseMove: function(e, target){
+        var me = this,
+            xy = e.getXY(),
+            s = me.startXY;
+
+        e.preventDefault();
+
+        me.lastXY = xy;
+        if (!me.active) {
+            if (Math.max(Math.abs(s[0]-xy[0]), Math.abs(s[1]-xy[1])) > me.tolerance) {
+                me.triggerStart(e);
+            } else {
+                return;
+            }
+        }
+
+        
+        if (me.fireEvent('mousemove', me, e) === false) {
+            me.onMouseUp(e);
+        } else {
+            me.onDrag(e);
+            me.fireEvent('drag', me, e);
+        }
+    },
+
+    onMouseUp: function(e) {
+        var me = this;
+        
+        
+        me.mouseIsDown = false;
+
+        
+        if (me.mouseIsOut) {
+            me.mouseIsOut = false;
+            me.onMouseOut(e);
+        }
+        e.preventDefault();
+        
+        
+        if (Ext.isIE && document.releaseCapture) {
+            document.releaseCapture();
+        }
+        
+        me.fireEvent('mouseup', me, e);
+        me.endDrag(e);
+    },
+
+    
+    endDrag: function(e) {
+        var me = this,
+            doc = Ext.getDoc(),
+            wasActive = me.active;
+
+        doc.un('mousemove', me.onMouseMove, me);
+        doc.un('mouseup', me.onMouseUp, me);
+        doc.un('selectstart', me.stopSelect, me);
+        me.clearStart();
+        me.active = false;
+        if (wasActive) {
+            me.onEnd(e);
+            me.fireEvent('dragend', me, e);
+        }
+        
+        delete me._constrainRegion;
+
+        
+        delete Ext.EventObject.dragTracked;
+    },
+
+    triggerStart: function(e) {
+        var me = this;
+        me.clearStart();
+        me.active = true;
+        me.onStart(e);
+        me.fireEvent('dragstart', me, e);
+    },
+
+    clearStart : function() {
+        var timer = this.timer;
+        if (timer) {
+            clearTimeout(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;
+    },
+
+    
+    getConstrainRegion: function() {
+        var me = this;
+        
+        if (me.constrainTo) {
+            if (me.constrainTo instanceof Ext.util.Region) {
+                return me.constrainTo;
+            }
+            if (!me._constrainRegion) {
+                me._constrainRegion = Ext.fly(me.constrainTo).getViewRegion();
+            }
+        } else {
+            if (!me._constrainRegion) {
+                me._constrainRegion = me.getDragCt().getViewRegion();
+            }
+        }
+        return me._constrainRegion;
+    },
+
+    getXY : function(constrain){
+        return constrain ? this.constrainModes[constrain](this, this.lastXY) : this.lastXY;
+    },
+
+    
+    getOffset : function(constrain){
+        var xy = this.getXY(constrain),
+            s = this.startXY;
+
+        return [xy[0]-s[0], xy[1]-s[1]];
+    },
+
+    constrainModes: {
+        
+        point: function(me, xy) {
+            var dr = me.dragRegion,
+                constrainTo = me.getConstrainRegion();
+
+            
+            if (!constrainTo) {
+                return xy;
+            }
+
+            dr.x = dr.left = dr[0] = dr.right = xy[0];
+            dr.y = dr.top = dr[1] = dr.bottom = xy[1];
+            dr.constrainTo(constrainTo);
+
+            return [dr.left, dr.top];
+        },
+
+        
+        dragTarget: function(me, xy) {
+            var s = me.startXY,
+                dr = me.startRegion.copy(),
+                constrainTo = me.getConstrainRegion(),
+                adjust;
+
+            
+            if (!constrainTo) {
+                return xy;
+            }
+
+            
+            
+            
+            dr.translateBy(xy[0]-s[0], xy[1]-s[1]);
+
+            
+            if (dr.right > constrainTo.right) {
+                xy[0] += adjust = (constrainTo.right - dr.right);    
+                dr.left += adjust;
+            }
+            if (dr.left < constrainTo.left) {
+                xy[0] += (constrainTo.left - dr.left);      
+            }
+
+            
+            if (dr.bottom > constrainTo.bottom) {
+                xy[1] += adjust = (constrainTo.bottom - dr.bottom);  
+                dr.top += adjust;
+            }
+            if (dr.top < constrainTo.top) {
+                xy[1] += (constrainTo.top - dr.top);        
+            }
+            return xy;
+        }
+    }
+});
+
+
+Ext.define('Ext.dd.DragZone', {
+    extend: 'Ext.dd.DragSource',
+
+    
+    constructor : function(el, config){
+        this.callParent([el, config]);
+        if (this.containerScroll) {
+            Ext.dd.ScrollManager.register(this.el);
+        }
+    },
+
+    
+
+    
+
+    
+    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(){
+        var me = this;
+        if (Ext.enableFx) {
+            Ext.fly(me.dragData.ddel).highlight(me.repairHighlightColor);
+        }
+        me.dragging = false;
+    },
+
+    
+    getRepairXY : function(e){
+        return Ext.fly(this.dragData.ddel).getXY();
+    },
+
+    destroy : function(){
+        this.callParent();
+        if (this.containerScroll) {
+            Ext.dd.ScrollManager.unregister(this.el);
+        }
+    }
+});
+
+
+Ext.define('Ext.dd.ScrollManager', {
+    singleton: true,
+    requires: [
+        'Ext.dd.DragDropManager'
+    ],
+
+    constructor: function() {
+        var ddm = Ext.dd.DragDropManager;
+        ddm.fireEvents = Ext.Function.createSequence(ddm.fireEvents, this.onFire, this);
+        ddm.stopDrag = Ext.Function.createSequence(ddm.stopDrag, this.onStop, this);
+        this.doScroll = Ext.Function.bind(this.doScroll, this);
+        this.ddmInstance = ddm;
+        this.els = {};
+        this.dragEl = null;
+        this.proc = {};
+    },
+
+    onStop: function(e){
+        var sm = Ext.dd.ScrollManager;
+        sm.dragEl = null;
+        sm.clearProc();
+    },
+
+    triggerRefresh: function() {
+        if (this.ddmInstance.dragCurrent) {
+            this.ddmInstance.refreshCache(this.ddmInstance.dragCurrent.groups);
+        }
+    },
+
+    doScroll: function() {
+        if (this.ddmInstance.dragCurrent) {
+            var proc   = this.proc,
+                procEl = proc.el,
+                ddScrollConfig = proc.el.ddScrollConfig,
+                inc = ddScrollConfig ? ddScrollConfig.increment : this.increment;
+
+            if (!this.animate) {
+                if (procEl.scroll(proc.dir, inc)) {
+                    this.triggerRefresh();
+                }
+            } else {
+                procEl.scroll(proc.dir, inc, true, this.animDuration, this.triggerRefresh);
+            }
+        }
+    },
+
+    clearProc: function() {
+        var proc = this.proc;
+        if (proc.id) {
+            clearInterval(proc.id);
+        }
+        proc.id = 0;
+        proc.el = null;
+        proc.dir = "";
+    },
+
+    startProc: function(el, dir) {
+        this.clearProc();
+        this.proc.el = el;
+        this.proc.dir = dir;
+        var group = el.ddScrollConfig ? el.ddScrollConfig.ddGroup : undefined,
+            freq  = (el.ddScrollConfig && el.ddScrollConfig.frequency)
+                  ? el.ddScrollConfig.frequency
+                  : this.frequency;
+
+        if (group === undefined || this.ddmInstance.dragCurrent.ddGroup == group) {
+            this.proc.id = setInterval(this.doScroll, freq);
+        }
+    },
+
+    onFire: function(e, isDrop) {
+        if (isDrop || !this.ddmInstance.dragCurrent) {
+            return;
+        }
+        if (!this.dragEl || this.dragEl != this.ddmInstance.dragCurrent) {
+            this.dragEl = this.ddmInstance.dragCurrent;
+            
+            this.refreshCache();
+        }
+
+        var xy = e.getXY(),
+            pt = e.getPoint(),
+            proc = this.proc,
+            els = this.els,
+            id, el, r, c;
+
+        for (id in els) {
+            el = els[id];
+            r = el._region;
+            c = el.ddScrollConfig ? el.ddScrollConfig : this;
+            if (r && r.contains(pt) && el.isScrollable()) {
+                if (r.bottom - pt.y <= c.vthresh) {
+                    if(proc.el != el){
+                        this.startProc(el, "down");
+                    }
+                    return;
+                }else if (r.right - pt.x <= c.hthresh) {
+                    if (proc.el != el) {
+                        this.startProc(el, "left");
+                    }
+                    return;
+                } else if(pt.y - r.top <= c.vthresh) {
+                    if (proc.el != el) {
+                        this.startProc(el, "up");
+                    }
+                    return;
+                } else if(pt.x - r.left <= c.hthresh) {
+                    if (proc.el != el) {
+                        this.startProc(el, "right");
+                    }
+                    return;
+                }
+            }
+        }
+        this.clearProc();
+    },
+
+    
+    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);
+            this.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 this.els[el.id];
+        }
+    },
+
+    
+    vthresh : 25,
+
+    
+    hthresh : 25,
+
+    
+    increment : 100,
+
+    
+    frequency : 500,
+
+    
+    animate: true,
+
+    
+    animDuration: 0.4,
+
+    
+    ddGroup: undefined,
+
+    
+    refreshCache : function(){
+        var els = this.els,
+            id;
+        for (id in els) {
+            if(typeof els[id] == 'object'){ 
+                els[id]._region = els[id].getRegion();
+            }
+        }
+    }
+});
+
+
+Ext.define('Ext.dd.DropTarget', {
+    extend: 'Ext.dd.DDTarget',
+    requires: ['Ext.dd.ScrollManager'],
+
+    
+    constructor : function(el, config){
+        this.el = Ext.get(el);
+
+        Ext.apply(this, config);
+
+        if(this.containerScroll){
+            Ext.dd.ScrollManager.register(this.el);
+        }
+
+        this.callParent([this.el.dom, this.ddGroup || this.group,
+              {isTarget: true}]);
+    },
+
+    
+    
+    
+    dropAllowed : Ext.baseCSSPrefix + 'dd-drop-ok',
+    
+    dropNotAllowed : Ext.baseCSSPrefix + 'dd-drop-nodrop',
+
+    
+    isTarget : true,
+
+    
+    isNotifyTarget : true,
+
+    
+    notifyEnter : function(dd, e, data){
+        if(this.overClass){
+            this.el.addCls(this.overClass);
+        }
+        return this.dropAllowed;
+    },
+
+    
+    notifyOver : function(dd, e, data){
+        return this.dropAllowed;
+    },
+
+    
+    notifyOut : function(dd, e, data){
+        if(this.overClass){
+            this.el.removeCls(this.overClass);
+        }
+    },
+
+    
+    notifyDrop : function(dd, e, data){
+        return false;
+    },
+
+    destroy : function(){
+        this.callParent();
+        if(this.containerScroll){
+            Ext.dd.ScrollManager.unregister(this.el);
+        }
+    }
+});
+
+
+Ext.define('Ext.dd.Registry', {
+    singleton: true,
+    constructor: function() {
+        this.elements = {}; 
+        this.handles = {}; 
+        this.autoIdSeed = 0;
+    },
+    
+    getId: function(el, autogen){
+        if(typeof el == "string"){
+            return el;
+        }
+        var id = el.id;
+        if(!id && autogen !== false){
+            id = "extdd-" + (++this.autoIdSeed);
+            el.id = id;
+        }
+        return id;
+    },
+    
+    
+    register : function(el, data){
+        data = data || {};
+        if (typeof el == "string") {
+            el = document.getElementById(el);
+        }
+        data.ddel = el;
+        this.elements[this.getId(el)] = data;
+        if (data.isHandle !== false) {
+            this.handles[data.ddel.id] = data;
+        }
+        if (data.handles) {
+            var hs = data.handles,
+                i, len;
+            for (i = 0, len = hs.length; i < len; i++) {
+                this.handles[this.getId(hs[i])] = data;
+            }
+        }
+    },
+
+    
+    unregister : function(el){
+        var id = this.getId(el, false),
+            data = this.elements[id],
+            hs, i, len;
+        if(data){
+            delete this.elements[id];
+            if(data.handles){
+                hs = data.handles;
+                for (i = 0, len = hs.length; i < len; i++) {
+                    delete this.handles[this.getId(hs[i], false)];
+                }
+            }
+        }
+    },
+
+    
+    getHandle : function(id){
+        if(typeof id != "string"){ 
+            id = id.id;
+        }
+        return this.handles[id];
+    },
+
+    
+    getHandleFromEvent : function(e){
+        var t = e.getTarget();
+        return t ? this.handles[t.id] : null;
+    },
+
+    
+    getTarget : function(id){
+        if(typeof id != "string"){ 
+            id = id.id;
+        }
+        return this.elements[id];
+    },
+
+    
+    getTargetFromEvent : function(e){
+        var t = e.getTarget();
+        return t ? this.elements[t.id] || this.handles[t.id] : null;
+    }
+});
+
+
+Ext.define('Ext.dd.DropZone', {
+    extend: 'Ext.dd.DropTarget',
+    requires: ['Ext.dd.Registry'],
+
+    
+    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.define('Ext.direct.Event', {
+
+    
+
+    alias: 'direct.event',
+
+    requires: ['Ext.direct.Manager'],
+
+    
+
+    status: true,
+
+    
+    constructor: function(config) {
+        Ext.apply(this, config);
+    },
+
+    
+    getData: function(){
+        return this.data;
+    }
+});
+
+
+Ext.define('Ext.direct.RemotingEvent', {
+    
+    
+   
+    extend: 'Ext.direct.Event',
+    
+    alias: 'direct.rpc',
+    
+    
+    
+    
+    getTransaction: function(){
+        return this.transaction || Ext.direct.Manager.getTransaction(this.tid);
+    }
+});
+
+
+Ext.define('Ext.direct.ExceptionEvent', {
+    
+    
+   
+    extend: 'Ext.direct.RemotingEvent',
+    
+    alias: 'direct.exception',
+    
+    
+   
+   status: false
+});
+
+
+Ext.define('Ext.direct.Provider', {
+
+    
+
+   alias: 'direct.provider',
+
+    mixins: {
+        observable: 'Ext.util.Observable'
+    },
+
+    
+
+   
+
+    constructor : function(config){
+        var me = this;
+
+        Ext.apply(me, config);
+        me.addEvents(
+            
+            'connect',
+            
+            'disconnect',
+            
+            'data',
+            
+            'exception'
+        );
+        me.mixins.observable.constructor.call(me, config);
+    },
+
+    
+    isConnected: function(){
+        return false;
+    },
+
+    
+    connect: Ext.emptyFn,
+
+    
+    disconnect: Ext.emptyFn
+});
+
+
+
+Ext.define('Ext.direct.JsonProvider', {
+
+    
+
+    extend: 'Ext.direct.Provider',
+
+    alias: 'direct.jsonprovider',
+
+    uses: ['Ext.direct.ExceptionEvent'],
+
+    
+
+   
+   parseResponse: function(response){
+        if (!Ext.isEmpty(response.responseText)) {
+            if (Ext.isObject(response.responseText)) {
+                return response.responseText;
+            }
+            return Ext.decode(response.responseText);
+        }
+        return null;
+    },
+
+    
+    createEvents: function(response){
+        var data = null,
+            events = [],
+            event,
+            i = 0,
+            len;
+
+        try{
+            data = this.parseResponse(response);
+        } catch(e) {
+            event = new Ext.direct.ExceptionEvent({
+                data: e,
+                xhr: response,
+                code: Ext.direct.Manager.exceptions.PARSE,
+                message: 'Error parsing json response: \n\n ' + data
+            });
+            return [event];
+        }
+
+        if (Ext.isArray(data)) {
+            for (len = data.length; i < len; ++i) {
+                events.push(this.createEvent(data[i]));
+            }
+        } else {
+            events.push(this.createEvent(data));
+        }
+        return events;
+    },
+
+    
+    createEvent: function(response){
+        return Ext.create('direct.' + response.type, response);
+    }
+});
+
+
+Ext.define('Ext.direct.PollingProvider', {
+    
+    
+    
+    extend: 'Ext.direct.JsonProvider',
+    
+    alias: 'direct.pollingprovider',
+    
+    uses: ['Ext.direct.ExceptionEvent'],
+    
+    requires: ['Ext.Ajax', 'Ext.util.DelayedTask'],
+    
+    
+    
+    
+    interval: 3000,
+
+    
+    
+    
+
+    
+    constructor : function(config){
+        this.callParent(arguments);
+        this.addEvents(
+            
+            'beforepoll',            
+            
+            'poll'
+        );
+    },
+
+    
+    isConnected: function(){
+        return !!this.pollTask;
+    },
+
+    
+    connect: function(){
+        var me = this, url = me.url;
+        
+        if (url && !me.pollTask) {
+            me.pollTask = Ext.TaskManager.start({
+                run: function(){
+                    if (me.fireEvent('beforepoll', me) !== false) {
+                        if (Ext.isFunction(url)) {
+                            url(me.baseParams);
+                        } else {
+                            Ext.Ajax.request({
+                                url: url,
+                                callback: me.onData,
+                                scope: me,
+                                params: me.baseParams
+                            });
+                        }
+                    }
+                },
+                interval: me.interval,
+                scope: me
+            });
+            me.fireEvent('connect', me);
+        } else if (!url) {
+        }
+    },
+
+    
+    disconnect: function(){
+        var me = this;
+        
+        if (me.pollTask) {
+            Ext.TaskManager.stop(me.pollTask);
+            delete me.pollTask;
+            me.fireEvent('disconnect', me);
+        }
+    },
+
+    
+    onData: function(opt, success, response){
+        var me = this, 
+            i = 0, 
+            len,
+            events;
+        
+        if (success) {
+            events = me.createEvents(response);
+            for (len = events.length; i < len; ++i) {
+                me.fireEvent('data', me, events[i]);
+            }
+        } else {
+            me.fireEvent('data', me, new Ext.direct.ExceptionEvent({
+                data: null,
+                code: Ext.direct.Manager.exceptions.TRANSPORT,
+                message: 'Unable to connect to the server.',
+                xhr: response
+            }));
+        }
+    }
+});
+
+
+Ext.define('Ext.direct.RemotingMethod', {
+
+    constructor: function(config){
+        var me = this,
+            params = Ext.isDefined(config.params) ? config.params : config.len,
+            name, pLen, p, param;
+
+        me.name = config.name;
+        me.formHandler = config.formHandler;
+        if (Ext.isNumber(params)) {
+            
+            me.len = params;
+            me.ordered = true;
+        } else {
+            
+            me.params = [];
+			pLen = params.length;
+            for (p = 0; p < pLen; p++) {
+                param = params[p];
+                name  = Ext.isObject(param) ? param.name : param;
+                me.params.push(name);
+            }
+        }
+    },
+    
+    getArgs: function(params, paramOrder, paramsAsHash){
+        var args = [],
+            i,
+            len;
+        
+        if (this.ordered) {
+            if (this.len > 0) {
+                
+                if (paramOrder) {
+                    for (i = 0, len = paramOrder.length; i < len; i++) {
+                        args.push(params[paramOrder[i]]);
+                    }
+                } else if (paramsAsHash) {
+                    
+                    args.push(params);
+                }
+            }
+        } else {
+            args.push(params);
+        } 
+        
+        return args;
+    },
+
+    
+    getCallData: function(args){
+        var me = this,
+            data = null,
+            len  = me.len,
+            params = me.params,
+            callback,
+            scope,
+            name;
+
+        if (me.ordered) {
+            callback = args[len];
+            scope = args[len + 1];
+            if (len !== 0) {
+                data = args.slice(0, len);
+            }
+        } else {
+            data = Ext.apply({}, args[0]);
+            callback = args[1];
+            scope = args[2];
+
+            
+            for (name in data) {
+                if (data.hasOwnProperty(name)) {
+                    if (!Ext.Array.contains(params, name)) {
+                        delete data[name];
+                    }
+                }
+            }
+        }
+
+        return {
+            data: data,
+            callback: callback,
+            scope: scope
+        };
+    }
+});
+
+
+Ext.define('Ext.direct.Transaction', {
+    
+    
+   
+    alias: 'direct.transaction',
+    alternateClassName: 'Ext.Direct.Transaction',
+   
+    statics: {
+        TRANSACTION_ID: 0
+    },
+   
+    
+
+    
+    constructor: function(config){
+        var me = this;
+        
+        Ext.apply(me, config);
+        me.id = me.tid = ++me.self.TRANSACTION_ID;
+        me.retryCount = 0;
+    },
+   
+    send: function(){
+         this.provider.queueTransaction(this);
+    },
+
+    retry: function(){
+        this.retryCount++;
+        this.send();
+    },
+
+    getProvider: function(){
+        return this.provider;
+    }
+});
+
+
+Ext.define('Ext.direct.RemotingProvider', {
+    
+    
+   
+    alias: 'direct.remotingprovider',
+    
+    extend: 'Ext.direct.JsonProvider', 
+    
+    requires: [
+        'Ext.util.MixedCollection', 
+        'Ext.util.DelayedTask', 
+        'Ext.direct.Transaction',
+        'Ext.direct.RemotingMethod'
+    ],
+   
+    
+   
+   
+    
+    
+    
+    
+    
+    
+    
+    
+    enableBuffer: 10,
+    
+    
+    maxRetries: 1,
+    
+    
+    timeout: undefined,
+    
+    constructor : function(config){
+        var me = this;
+        me.callParent(arguments);
+        me.addEvents(
+                        
+            'beforecall',            
+                        
+            'call'
+        );
+        me.namespace = (Ext.isString(me.namespace)) ? Ext.ns(me.namespace) : me.namespace || window;
+        me.transactions = new Ext.util.MixedCollection();
+        me.callBuffer = [];
+    },
+    
+    
+    initAPI : function(){
+        var actions = this.actions,
+            namespace = this.namespace,
+            action,
+            cls,
+            methods,
+            i,
+            len,
+            method;
+            
+        for (action in actions) {
+            if (actions.hasOwnProperty(action)) {
+                cls = namespace[action];
+                if (!cls) {
+                    cls = namespace[action] = {};
+                }
+                methods = actions[action];
+                
+                for (i = 0, len = methods.length; i < len; ++i) {
+                    method = new Ext.direct.RemotingMethod(methods[i]);
+                    cls[method.name] = this.createHandler(action, method);
+                }
+            }
+        }
+    },
+    
+    
+    createHandler : function(action, method){
+        var me = this,
+            handler;
+        
+        if (!method.formHandler) {
+            handler = function(){
+                me.configureRequest(action, method, Array.prototype.slice.call(arguments, 0));
+            };
+        } else {
+            handler = function(form, callback, scope){
+                me.configureFormRequest(action, method, form, callback, scope);
+            };
+        }
+        handler.directCfg = {
+            action: action,
+            method: method
+        };
+        return handler;
+    },
+    
+    
+    isConnected: function(){
+        return !!this.connected;
+    },
+
+    
+    connect: function(){
+        var me = this;
+        
+        if (me.url) {
+            me.initAPI();
+            me.connected = true;
+            me.fireEvent('connect', me);
+        } else if(!me.url) {
+        }
+    },
+
+    
+    disconnect: function(){
+        var me = this;
+        
+        if (me.connected) {
+            me.connected = false;
+            me.fireEvent('disconnect', me);
+        }
+    },
+    
+    
+    runCallback: function(transaction, event){
+        var success = !!event.status,
+            funcName = success ? 'success' : 'failure',
+            callback,
+            result;
+        
+        if (transaction && transaction.callback) {
+            callback = transaction.callback;
+            result = Ext.isDefined(event.result) ? event.result : event.data;
+        
+            if (Ext.isFunction(callback)) {
+                callback(result, event, success);
+            } else {
+                Ext.callback(callback[funcName], callback.scope, [result, event, success]);
+                Ext.callback(callback.callback, callback.scope, [result, event, success]);
+            }
+        }
+    },
+    
+    
+    onData: function(options, success, response){
+        var me = this,
+            i = 0,
+            len,
+            events,
+            event,
+            transaction,
+            transactions;
+            
+        if (success) {
+            events = me.createEvents(response);
+            for (len = events.length; i < len; ++i) {
+                event = events[i];
+                transaction = me.getTransaction(event);
+                me.fireEvent('data', me, event);
+                if (transaction) {
+                    me.runCallback(transaction, event, true);
+                    Ext.direct.Manager.removeTransaction(transaction);
+                }
+            }
+        } else {
+            transactions = [].concat(options.transaction);
+            for (len = transactions.length; i < len; ++i) {
+                transaction = me.getTransaction(transactions[i]);
+                if (transaction && transaction.retryCount < me.maxRetries) {
+                    transaction.retry();
+                } else {
+                    event = new Ext.direct.ExceptionEvent({
+                        data: null,
+                        transaction: transaction,
+                        code: Ext.direct.Manager.exceptions.TRANSPORT,
+                        message: 'Unable to connect to the server.',
+                        xhr: response
+                    });
+                    me.fireEvent('data', me, event);
+                    if (transaction) {
+                        me.runCallback(transaction, event, false);
+                        Ext.direct.Manager.removeTransaction(transaction);
+                    }
+                }
+            }
+        }
+    },
+    
+    
+    getTransaction: function(options){
+        return options && options.tid ? Ext.direct.Manager.getTransaction(options.tid) : null;
+    },
+    
+    
+    configureRequest: function(action, method, args){
+        var me = this,
+            callData = method.getCallData(args),
+            data = callData.data, 
+            callback = callData.callback, 
+            scope = callData.scope,
+            transaction;
+
+        transaction = new Ext.direct.Transaction({
+            provider: me,
+            args: args,
+            action: action,
+            method: method.name,
+            data: data,
+            callback: scope && Ext.isFunction(callback) ? Ext.Function.bind(callback, scope) : callback
+        });
+
+        if (me.fireEvent('beforecall', me, transaction, method) !== false) {
+            Ext.direct.Manager.addTransaction(transaction);
+            me.queueTransaction(transaction);
+            me.fireEvent('call', me, transaction, method);
+        }
+    },
+    
+    
+    getCallData: function(transaction){
+        return {
+            action: transaction.action,
+            method: transaction.method,
+            data: transaction.data,
+            type: 'rpc',
+            tid: transaction.id
+        };
+    },
+    
+    
+    sendRequest : function(data){
+        var me = this,
+            request = {
+                url: me.url,
+                callback: me.onData,
+                scope: me,
+                transaction: data,
+                timeout: me.timeout
+            }, callData,
+            enableUrlEncode = me.enableUrlEncode,
+            i = 0,
+            len,
+            params;
+            
+
+        if (Ext.isArray(data)) {
+            callData = [];
+            for (len = data.length; i < len; ++i) {
+                callData.push(me.getCallData(data[i]));
+            }
+        } else {
+            callData = me.getCallData(data);
+        }
+
+        if (enableUrlEncode) {
+            params = {};
+            params[Ext.isString(enableUrlEncode) ? enableUrlEncode : 'data'] = Ext.encode(callData);
+            request.params = params;
+        } else {
+            request.jsonData = callData;
+        }
+        Ext.Ajax.request(request);
+    },
+    
+    
+    queueTransaction: function(transaction){
+        var me = this,
+            enableBuffer = me.enableBuffer;
+        
+        if (transaction.form) {
+            me.sendFormRequest(transaction);
+            return;
+        }
+        
+        me.callBuffer.push(transaction);
+        if (enableBuffer) {
+            if (!me.callTask) {
+                me.callTask = new Ext.util.DelayedTask(me.combineAndSend, me);
+            }
+            me.callTask.delay(Ext.isNumber(enableBuffer) ? enableBuffer : 10);
+        } else {
+            me.combineAndSend();
+        }
+    },
+    
+    
+    combineAndSend : function(){
+        var buffer = this.callBuffer,
+            len = buffer.length;
+            
+        if (len > 0) {
+            this.sendRequest(len == 1 ? buffer[0] : buffer);
+            this.callBuffer = [];
+        }
+    },
+    
+    
+    configureFormRequest : function(action, method, form, callback, scope){
+        var me = this,
+            transaction = new Ext.direct.Transaction({
+                provider: me,
+                action: action,
+                method: method.name,
+                args: [form, callback, scope],
+                callback: scope && Ext.isFunction(callback) ? Ext.Function.bind(callback, scope) : callback,
+                isForm: true
+            }),
+            isUpload,
+            params;
+
+        if (me.fireEvent('beforecall', me, transaction, method) !== false) {
+            Ext.direct.Manager.addTransaction(transaction);
+            isUpload = String(form.getAttribute("enctype")).toLowerCase() == 'multipart/form-data';
+            
+            params = {
+                extTID: transaction.id,
+                extAction: action,
+                extMethod: method.name,
+                extType: 'rpc',
+                extUpload: String(isUpload)
+            };
+            
+            
+            
+            Ext.apply(transaction, {
+                form: Ext.getDom(form),
+                isUpload: isUpload,
+                params: callback && Ext.isObject(callback.params) ? Ext.apply(params, callback.params) : params
+            });
+            me.fireEvent('call', me, transaction, method);
+            me.sendFormRequest(transaction);
+        }
+    },
+    
+    
+    sendFormRequest: function(transaction){
+        Ext.Ajax.request({
+            url: this.url,
+            params: transaction.params,
+            callback: this.onData,
+            scope: this,
+            form: transaction.form,
+            isUpload: transaction.isUpload,
+            transaction: transaction
+        });
+    }
+    
+});
+
+
+Ext.define('Ext.draw.Matrix', {
+
+    
+
+    requires: ['Ext.draw.Draw'],
+
+    
+
+    constructor: function(a, b, c, d, e, f) {
+        if (a != null) {
+            this.matrix = [[a, c, e], [b, d, f], [0, 0, 1]];
+        }
+        else {
+            this.matrix = [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
+        }
+    },
+
+    add: function(a, b, c, d, e, f) {
+        var me = this,
+            out = [[], [], []],
+            matrix = [[a, c, e], [b, d, f], [0, 0, 1]],
+            x,
+            y,
+            z,
+            res;
+
+        for (x = 0; x < 3; x++) {
+            for (y = 0; y < 3; y++) {
+                res = 0;
+                for (z = 0; z < 3; z++) {
+                    res += me.matrix[x][z] * matrix[z][y];
+                }
+                out[x][y] = res;
+            }
+        }
+        me.matrix = out;
+    },
+
+    prepend: function(a, b, c, d, e, f) {
+        var me = this,
+            out = [[], [], []],
+            matrix = [[a, c, e], [b, d, f], [0, 0, 1]],
+            x,
+            y,
+            z,
+            res;
+
+        for (x = 0; x < 3; x++) {
+            for (y = 0; y < 3; y++) {
+                res = 0;
+                for (z = 0; z < 3; z++) {
+                    res += matrix[x][z] * me.matrix[z][y];
+                }
+                out[x][y] = res;
+            }
+        }
+        me.matrix = out;
+    },
+
+    invert: function() {
+        var matrix = this.matrix,
+            a = matrix[0][0],
+            b = matrix[1][0],
+            c = matrix[0][1],
+            d = matrix[1][1],
+            e = matrix[0][2],
+            f = matrix[1][2],
+            x = a * d - b * c;
+        return new Ext.draw.Matrix(d / x, -b / x, -c / x, a / x, (c * f - d * e) / x, (b * e - a * f) / x);
+    },
+
+    clone: function() {
+        var matrix = this.matrix,
+            a = matrix[0][0],
+            b = matrix[1][0],
+            c = matrix[0][1],
+            d = matrix[1][1],
+            e = matrix[0][2],
+            f = matrix[1][2];
+        return new Ext.draw.Matrix(a, b, c, d, e, f);
+    },
+
+    translate: function(x, y) {
+        this.prepend(1, 0, 0, 1, x, y);
+    },
+
+    scale: function(x, y, cx, cy) {
+        var me = this;
+        if (y == null) {
+            y = x;
+        }
+        me.add(x, 0, 0, y, cx * (1 - x), cy * (1 - y));
+    },
+
+    rotate: function(a, x, y) {
+        a = Ext.draw.Draw.rad(a);
+        var me = this,
+            cos = +Math.cos(a).toFixed(9),
+            sin = +Math.sin(a).toFixed(9);
+        me.add(cos, sin, -sin, cos, x - cos * x + sin * y, -(sin * x) + y - cos * y);
+    },
+
+    x: function(x, y) {
+        var matrix = this.matrix;
+        return x * matrix[0][0] + y * matrix[0][1] + matrix[0][2];
+    },
+
+    y: function(x, y) {
+        var matrix = this.matrix;
+        return x * matrix[1][0] + y * matrix[1][1] + matrix[1][2];
+    },
+
+    get: function(i, j) {
+        return + this.matrix[i][j].toFixed(4);
+    },
+
+    toString: function() {
+        var me = this;
+        return [me.get(0, 0), me.get(0, 1), me.get(1, 0), me.get(1, 1), 0, 0].join();
+    },
+
+    toSvg: function() {
+        var me = this;
+        return "matrix(" + [me.get(0, 0), me.get(1, 0), me.get(0, 1), me.get(1, 1), me.get(0, 2), me.get(1, 2)].join() + ")";
+    },
+
+    toFilter: function(dx, dy) {
+        var me = this;
+        dx = dx || 0;
+        dy = dy || 0;
+        return "progid:DXImageTransform.Microsoft.Matrix(sizingMethod='auto expand', filterType='bilinear', M11=" + me.get(0, 0) +
+            ", M12=" + me.get(0, 1) + ", M21=" + me.get(1, 0) + ", M22=" + me.get(1, 1) +
+            ", Dx=" + (me.get(0, 2) + dx) + ", Dy=" + (me.get(1, 2) + dy) + ")";
+    },
+
+    offset: function() {
+        var matrix = this.matrix;
+        return [(matrix[0][2] || 0).toFixed(4), (matrix[1][2] || 0).toFixed(4)];
+    },
+
+    
+    split: function () {
+        function norm(a) {
+            return a[0] * a[0] + a[1] * a[1];
+        }
+        function normalize(a) {
+            var mag = Math.sqrt(norm(a));
+            a[0] /= mag;
+            a[1] /= mag;
+        }
+        var matrix = this.matrix,
+            out = {
+                translateX: matrix[0][2],
+                translateY: matrix[1][2]
+            },
+            row;
+
+        
+        row = [[matrix[0][0], matrix[0][1]], [matrix[1][1], matrix[1][1]]];
+        out.scaleX = Math.sqrt(norm(row[0]));
+        normalize(row[0]);
+
+        out.shear = row[0][0] * row[1][0] + row[0][1] * row[1][1];
+        row[1] = [row[1][0] - row[0][0] * out.shear, row[1][1] - row[0][1] * out.shear];
+
+        out.scaleY = Math.sqrt(norm(row[1]));
+        normalize(row[1]);
+        out.shear /= out.scaleY;
+
+        
+        out.rotate = Math.asin(-row[0][1]);
+
+        out.isSimple = !+out.shear.toFixed(9) && (out.scaleX.toFixed(9) == out.scaleY.toFixed(9) || !out.rotate);
+
+        return out;
+    }
+});
+
+
+Ext.define('Ext.draw.SpriteDD', {
+    extend: 'Ext.dd.DragSource',
+
+    constructor : function(sprite, cfg){
+        var me = this,
+            el = sprite.el;
+        me.sprite = sprite;
+        me.el = el;
+        me.dragData = {el: el, sprite: sprite};
+        me.callParent([el, cfg]);
+        me.sprite.setStyle('cursor', 'move');
+    },
+
+    showFrame: Ext.emptyFn,
+    createFrame : Ext.emptyFn,
+
+    getDragEl : function(e){
+        return this.el;
+    },
+    
+    getRegion: function() {
+        var me = this,
+            el = me.el,
+            pos, x1, x2, y1, y2, t, r, b, l, bbox, sprite;
+        
+        sprite = me.sprite;
+        bbox = sprite.getBBox();
+        
+        try {
+            pos = Ext.Element.getXY(el);
+        } catch (e) { }
+
+        if (!pos) {
+            return null;
+        }
+
+        x1 = pos[0];
+        x2 = x1 + bbox.width;
+        y1 = pos[1];
+        y2 = y1 + bbox.height;
+        
+        return new Ext.util.Region(y1, x2, y2, x1);
+    },
+
+    
+     
+    startDrag: function(x, y) {
+        var me = this,
+            attr = me.sprite.attr;
+        me.prev = me.sprite.surface.transformToViewBox(x, y);
+    },
+
+    onDrag: function(e) {
+        var xy = e.getXY(),
+            me = this,
+            sprite = me.sprite,
+            attr = sprite.attr, dx, dy;
+        xy = me.sprite.surface.transformToViewBox(xy[0], xy[1]);
+        dx = xy[0] - me.prev[0];
+        dy = xy[1] - me.prev[1];
+        sprite.setAttributes({
+            translate: {
+                x: attr.translation.x + dx,
+                y: attr.translation.y + dy
+            }
+        }, true);
+        me.prev = xy;
+    },
+
+    setDragElPos: function () {
+        
+        return false;
+    }
+});
+
+
+Ext.define('Ext.draw.Sprite', {
+
+    
+
+    mixins: {
+        observable: 'Ext.util.Observable',
+        animate: 'Ext.util.Animate'
+    },
+
+    requires: ['Ext.draw.SpriteDD'],
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    dirty: false,
+    dirtyHidden: false,
+    dirtyTransform: false,
+    dirtyPath: true,
+    dirtyFont: true,
+    zIndexDirty: true,
+
+    
+    isSprite: true,
+    zIndex: 0,
+    fontProperties: [
+        'font',
+        'font-size',
+        'font-weight',
+        'font-style',
+        'font-family',
+        'text-anchor',
+        'text'
+    ],
+    pathProperties: [
+        'x',
+        'y',
+        'd',
+        'path',
+        'height',
+        'width',
+        'radius',
+        'r',
+        'rx',
+        'ry',
+        'cx',
+        'cy'
+    ],
+    constructor: function(config) {
+        var me = this;
+        config = Ext.merge({}, config || {});
+        me.id = Ext.id(null, 'ext-sprite-');
+        me.transformations = [];
+        Ext.copyTo(this, config, 'surface,group,type,draggable');
+        
+        me.bbox = {};
+        me.attr = {
+            zIndex: 0,
+            translation: {
+                x: null,
+                y: null
+            },
+            rotation: {
+                degrees: null,
+                x: null,
+                y: null
+            },
+            scaling: {
+                x: null,
+                y: null,
+                cx: null,
+                cy: null
+            }
+        };
+        
+        delete config.surface;
+        delete config.group;
+        delete config.type;
+        delete config.draggable;
+        me.setAttributes(config);
+        me.addEvents(
+            
+            'beforedestroy',
+            
+            'destroy',
+            
+            'render',
+            
+            'mousedown',
+            
+            'mouseup',
+            
+            'mouseover',
+            
+            'mouseout',
+            
+            'mousemove',
+            
+            'click'
+        );
+        me.mixins.observable.constructor.apply(this, arguments);
+    },
+
+    
+
+    initDraggable: function() {
+        var me = this;
+        me.draggable = true;
+        
+        if (!me.el) {
+            me.surface.createSpriteElement(me);
+        }
+        me.dd = new Ext.draw.SpriteDD(me, Ext.isBoolean(me.draggable) ? null : me.draggable);
+        me.on('beforedestroy', me.dd.destroy, me.dd);
+    },
+
+    
+    setAttributes: function(attrs, redraw) {
+        var me = this,
+            fontProps = me.fontProperties,
+            fontPropsLength = fontProps.length,
+            pathProps = me.pathProperties,
+            pathPropsLength = pathProps.length,
+            hasSurface = !!me.surface,
+            custom = hasSurface && me.surface.customAttributes || {},
+            spriteAttrs = me.attr,
+            dirtyBBox = false,
+            attr, i, newTranslation, translation, newRotate, rotation, newScaling, scaling;
+
+        attrs = Ext.apply({}, attrs);
+        for (attr in custom) {
+            if (attrs.hasOwnProperty(attr) && typeof custom[attr] == "function") {
+                Ext.apply(attrs, custom[attr].apply(me, [].concat(attrs[attr])));
+            }
+        }
+
+        
+        if (!!attrs.hidden !== !!spriteAttrs.hidden) {
+            me.dirtyHidden = true;
+        }
+
+        
+        for (i = 0; i < pathPropsLength; i++) {
+            attr = pathProps[i];
+            if (attr in attrs && attrs[attr] !== spriteAttrs[attr]) {
+                me.dirtyPath = true;
+                dirtyBBox = true;
+                break;
+            }
+        }
+
+        
+        if ('zIndex' in attrs) {
+            me.zIndexDirty = true;
+        }
+
+        
+        if ('text' in attrs) {
+            me.dirtyFont = true;
+            dirtyBBox = true;
+        }
+
+        for (i = 0; i < fontPropsLength; i++) {
+            attr = fontProps[i];
+            if (attr in attrs && attrs[attr] !== spriteAttrs[attr]) {
+                me.dirtyFont = true;
+                dirtyBBox = true;
+                break;
+            }
+        }
+
+        newTranslation = attrs.translation || attrs.translate;
+        delete attrs.translate;
+        delete attrs.translation;
+        translation = spriteAttrs.translation;
+        if (newTranslation) {
+            if (('x' in newTranslation && newTranslation.x !== translation.x) ||
+                ('y' in newTranslation && newTranslation.y !== translation.y)) {
+                me.dirtyTransform = true;
+                translation.x = newTranslation.x;
+                translation.y = newTranslation.y;
+            }
+        }
+
+        newRotate = attrs.rotation || attrs.rotate;
+        rotation = spriteAttrs.rotation;
+        delete attrs.rotate;
+        delete attrs.rotation;
+        if (newRotate) {
+            if (('x' in newRotate && newRotate.x !== rotation.x) ||
+                ('y' in newRotate && newRotate.y !== rotation.y) ||
+                ('degrees' in newRotate && newRotate.degrees !== rotation.degrees)) {
+                me.dirtyTransform = true;
+                rotation.x = newRotate.x;
+                rotation.y = newRotate.y;
+                rotation.degrees = newRotate.degrees;
+            }
+        }
+
+        newScaling = attrs.scaling || attrs.scale;
+        scaling = spriteAttrs.scaling;
+        delete attrs.scale;
+        delete attrs.scaling;
+        if (newScaling) {
+            if (('x' in newScaling && newScaling.x !== scaling.x) ||
+                ('y' in newScaling && newScaling.y !== scaling.y) ||
+                ('cx' in newScaling && newScaling.cx !== scaling.cx) ||
+                ('cy' in newScaling && newScaling.cy !== scaling.cy)) {
+                me.dirtyTransform = true;
+                scaling.x = newScaling.x;
+                scaling.y = newScaling.y;
+                scaling.cx = newScaling.cx;
+                scaling.cy = newScaling.cy;
+            }
+        }
+
+        
+        if (!me.dirtyTransform && dirtyBBox) {
+            if (spriteAttrs.scaling.x === null ||
+                spriteAttrs.scaling.y === null ||
+                spriteAttrs.rotation.y === null ||
+                spriteAttrs.rotation.y === null) {
+                me.dirtyTransform = true;
+            }
+        }
+
+        Ext.apply(spriteAttrs, attrs);
+        me.dirty = true;
+
+        if (redraw === true && hasSurface) {
+            me.redraw();
+        }
+        return this;
+    },
+
+    
+    getBBox: function() {
+        return this.surface.getBBox(this);
+    },
+
+    setText: function(text) {
+        return this.surface.setText(this, text);
+    },
+
+    
+    hide: function(redraw) {
+        this.setAttributes({
+            hidden: true
+        }, redraw);
+        return this;
+    },
+
+    
+    show: function(redraw) {
+        this.setAttributes({
+            hidden: false
+        }, redraw);
+        return this;
+    },
+
+    
+    remove: function() {
+        if (this.surface) {
+            this.surface.remove(this);
+            return true;
+        }
+        return false;
+    },
+
+    onRemove: function() {
+        this.surface.onRemove(this);
+    },
+
+    
+    destroy: function() {
+        var me = this;
+        if (me.fireEvent('beforedestroy', me) !== false) {
+            me.remove();
+            me.surface.onDestroy(me);
+            me.clearListeners();
+            me.fireEvent('destroy');
+        }
+    },
+
+    
+    redraw: function() {
+        this.surface.renderItem(this);
+        return this;
+    },
+
+    
+    setStyle: function() {
+        this.el.setStyle.apply(this.el, arguments);
+        return this;
+    },
+
+    
+    addCls: function(obj) {
+        this.surface.addCls(this, obj);
+        return this;
+    },
+
+    
+    removeCls: function(obj) {
+        this.surface.removeCls(this, obj);
+        return this;
+    }
+});
+
+
+Ext.define('Ext.draw.Text', {
+    extend: 'Ext.draw.Component',
+    uses: ['Ext.util.CSS'],
+    alias: 'widget.text',
+
+    
+    text: '',
+
+    
+
+    
+
+    focusable: false,
+    viewBox: false,
+    autoSize: true,
+    baseCls: Ext.baseCSSPrefix + 'surface ' + Ext.baseCSSPrefix + 'draw-text',
+
+    initComponent: function() {
+        var me = this;
+
+        me.textConfig = Ext.apply({
+            type: 'text',
+            text: me.text,
+            rotate: {
+                degrees: me.degrees || 0
+            }
+        }, me.textStyle);
+        Ext.apply(me.textConfig, me.getStyles(me.styleSelectors || me.styleSelector));
+
+        
+        
+        me.initialConfig.items = [me.textConfig];
+        me.callParent(arguments);
+    },
+
+    
+    getStyles: function(selectors) {
+        selectors = Ext.Array.from(selectors);
+        var i = 0,
+            len = selectors.length,
+            rule,
+            style,
+            prop,
+            result = {};
+
+        for (; i < len; i++) {
+            
+            rule = Ext.util.CSS.getRule(selectors[i]);
+            if (rule) {
+                style = rule.style;
+                if (style) {
+                    Ext.apply(result, {
+                        'font-family': style.fontFamily,
+                        'font-weight': style.fontWeight,
+                        'line-height': style.lineHeight,
+                        'font-size': style.fontSize,
+                        fill: style.color
+                    });
+                }
+            }
+        }
+        return result;
+    },
+
+    
+    setAngle: function(degrees) {
+        var me = this,
+            surface,
+            sprite;
+            
+        if (me.rendered) {
+            surface = me.surface;
+            sprite = surface.items.items[0];
+
+            me.degrees = degrees;
+            sprite.setAttributes({
+                rotate: {
+                    degrees: degrees
+                }
+            }, true);
+            if (me.autoSize || me.viewBox) {
+                me.updateLayout();
+            }
+        } else {
+            me.degrees = degrees;
+        }
+    },
+
+    
+    setText: function(text) {
+        var me = this,
+            surface,
+            sprite;
+            
+        if (me.rendered) {
+            surface = me.surface;
+            sprite = surface.items.items[0];
+
+            me.text = text || '';
+            surface.remove(sprite);
+            me.textConfig.type = 'text';
+            me.textConfig.text = me.text;
+            sprite = surface.add(me.textConfig);
+            sprite.setAttributes({
+                rotate: {
+                    degrees: me.degrees
+                }
+            }, true);
+            if (me.autoSize || me.viewBox) {
+                me.updateLayout();
+            }
+        } else {
+            me.on({
+                render: function() {
+                    me.setText(text);
+                },
+                single: true
+            });
+        }
+    }
+});
+
+
+Ext.define('Ext.draw.engine.ImageExporter', {
+    singleton: true,
+
+    
+    defaultUrl: 'http://svg.sencha.io',
+
+    
+    supportedTypes: ['image/png', 'image/jpeg'],
+
+    
+    widthParam: 'width',
+
+    
+    heightParam: 'height',
+
+    
+    typeParam: 'type',
+
+    
+    svgParam: 'svg',
+
+    formCls: Ext.baseCSSPrefix + 'hide-display',
+
+    
+    generate: function(surface, config) {
+        config = config || {};
+        var me = this,
+            type = config.type,
+            form;
+
+        if (Ext.Array.indexOf(me.supportedTypes, type) === -1) {
+            return false;
+        }
+
+        form = Ext.getBody().createChild({
+            tag: 'form',
+            method: 'POST',
+            action: config.url || me.defaultUrl,
+            cls: me.formCls,
+            children: [{
+                tag: 'input',
+                type: 'hidden',
+                name: config.widthParam || me.widthParam,
+                value: config.width || surface.width
+            }, {
+                tag: 'input',
+                type: 'hidden',
+                name: config.heightParam || me.heightParam,
+                value: config.height || surface.height
+            }, {
+                tag: 'input',
+                type: 'hidden',
+                name: config.typeParam || me.typeParam,
+                value: type
+            }, {
+                tag: 'input',
+                type: 'hidden',
+                name: config.svgParam || me.svgParam
+            }]
+        });
+
+        
+        form.last(null, true).value = Ext.draw.engine.SvgExporter.generate(surface);
+
+        form.dom.submit();
+        form.remove();
+        return true;
+    }
+
+});
+
+
+Ext.define('Ext.draw.engine.Svg', {
+
+    
+
+    extend: 'Ext.draw.Surface',
+
+    requires: ['Ext.draw.Draw', 'Ext.draw.Sprite', 'Ext.draw.Matrix', 'Ext.Element'],
+
+    
+
+    engine: 'Svg',
+
+    trimRe: /^\s+|\s+$/g,
+    spacesRe: /\s+/,
+    xlink: "http:/" + "/www.w3.org/1999/xlink",
+
+    translateAttrs: {
+        radius: "r",
+        radiusX: "rx",
+        radiusY: "ry",
+        path: "d",
+        lineWidth: "stroke-width",
+        fillOpacity: "fill-opacity",
+        strokeOpacity: "stroke-opacity",
+        strokeLinejoin: "stroke-linejoin"
+    },
+
+    parsers: {},
+
+    minDefaults: {
+        circle: {
+            cx: 0,
+            cy: 0,
+            r: 0,
+            fill: "none",
+            stroke: null,
+            "stroke-width": null,
+            opacity: null,
+            "fill-opacity": null,
+            "stroke-opacity": null
+        },
+        ellipse: {
+            cx: 0,
+            cy: 0,
+            rx: 0,
+            ry: 0,
+            fill: "none",
+            stroke: null,
+            "stroke-width": null,
+            opacity: null,
+            "fill-opacity": null,
+            "stroke-opacity": null
+        },
+        rect: {
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0,
+            rx: 0,
+            ry: 0,
+            fill: "none",
+            stroke: null,
+            "stroke-width": null,
+            opacity: null,
+            "fill-opacity": null,
+            "stroke-opacity": null
+        },
+        text: {
+            x: 0,
+            y: 0,
+            "text-anchor": "start",
+            "font-family": null,
+            "font-size": null,
+            "font-weight": null,
+            "font-style": null,
+            fill: "#000",
+            stroke: null,
+            "stroke-width": null,
+            opacity: null,
+            "fill-opacity": null,
+            "stroke-opacity": null
+        },
+        path: {
+            d: "M0,0",
+            fill: "none",
+            stroke: null,
+            "stroke-width": null,
+            opacity: null,
+            "fill-opacity": null,
+            "stroke-opacity": null
+        },
+        image: {
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0,
+            preserveAspectRatio: "none",
+            opacity: null
+        }
+    },
+
+    createSvgElement: function(type, attrs) {
+        var el = this.domRef.createElementNS("http:/" + "/www.w3.org/2000/svg", type),
+            key;
+        if (attrs) {
+            for (key in attrs) {
+                el.setAttribute(key, String(attrs[key]));
+            }
+        }
+        return el;
+    },
+
+    createSpriteElement: function(sprite) {
+        
+        var el = this.createSvgElement(sprite.type);
+        el.id = sprite.id;
+        if (el.style) {
+            el.style.webkitTapHighlightColor = "rgba(0,0,0,0)";
+        }
+        sprite.el = Ext.get(el);
+        this.applyZIndex(sprite); 
+        sprite.matrix = new Ext.draw.Matrix();
+        sprite.bbox = {
+            plain: 0,
+            transform: 0
+        };
+        this.applyAttrs(sprite);
+        this.applyTransformations(sprite);
+        sprite.fireEvent("render", sprite);
+        return el;
+    },
+    
+    getBBoxText: function (sprite) {
+        var bbox = {},
+            bb, height, width, i, ln, el;
+
+        if (sprite && sprite.el) {
+            el = sprite.el.dom;
+            try {
+                bbox = el.getBBox();
+                return bbox;
+            } catch(e) {
+                
+            }
+            bbox = {x: bbox.x, y: Infinity, width: 0, height: 0};
+            ln = el.getNumberOfChars();
+            for (i = 0; i < ln; i++) {
+                bb = el.getExtentOfChar(i);
+                bbox.y = Math.min(bb.y, bbox.y);
+                height = bb.y + bb.height - bbox.y;
+                bbox.height = Math.max(bbox.height, height);
+                width = bb.x + bb.width - bbox.x;
+                bbox.width = Math.max(bbox.width, width);
+            }
+            return bbox;
+        }
+    },
+
+    hide: function() {
+        Ext.get(this.el).hide();
+    },
+
+    show: function() {
+        Ext.get(this.el).show();
+    },
+
+    hidePrim: function(sprite) {
+        this.addCls(sprite, Ext.baseCSSPrefix + 'hide-visibility');
+    },
+
+    showPrim: function(sprite) {
+        this.removeCls(sprite, Ext.baseCSSPrefix + 'hide-visibility');
+    },
+
+    getDefs: function() {
+        return this._defs || (this._defs = this.createSvgElement("defs"));
+    },
+
+    transform: function(sprite, matrixOnly) {
+        var me = this,
+            matrix = new Ext.draw.Matrix(),
+            transforms = sprite.transformations,
+            transformsLength = transforms.length,
+            i = 0,
+            transform, type;
+            
+        for (; i < transformsLength; i++) {
+            transform = transforms[i];
+            type = transform.type;
+            if (type == "translate") {
+                matrix.translate(transform.x, transform.y);
+            }
+            else if (type == "rotate") {
+                matrix.rotate(transform.degrees, transform.x, transform.y);
+            }
+            else if (type == "scale") {
+                matrix.scale(transform.x, transform.y, transform.centerX, transform.centerY);
+            }
+        }
+        sprite.matrix = matrix;
+        if (!matrixOnly) {
+            sprite.el.set({transform: matrix.toSvg()});
+        }
+    },
+
+    setSize: function(width, height) {
+        var me = this,
+            el = me.el;
+        
+        width = +width || me.width;
+        height = +height || me.height;
+        me.width = width;
+        me.height = height;
+
+        el.setSize(width, height);
+        el.set({
+            width: width,
+            height: height
+        });
+        me.callParent([width, height]);
+    },
+
+    
+    getRegion: function() {
+        
+        
+        var svgXY = this.el.getXY(),
+            rectXY = this.bgRect.getXY(),
+            max = Math.max,
+            x = max(svgXY[0], rectXY[0]),
+            y = max(svgXY[1], rectXY[1]);
+        return {
+            left: x,
+            top: y,
+            right: x + this.width,
+            bottom: y + this.height
+        };
+    },
+
+    onRemove: function(sprite) {
+        if (sprite.el) {
+            sprite.el.destroy();
+            delete sprite.el;
+        }
+        this.callParent(arguments);
+    },
+    
+    setViewBox: function(x, y, width, height) {
+        if (isFinite(x) && isFinite(y) && isFinite(width) && isFinite(height)) {
+            this.callParent(arguments);
+            this.el.dom.setAttribute("viewBox", [x, y, width, height].join(" "));
+        }
+    },
+
+    render: function (container) {
+        var me = this,
+            width,
+            height,
+            el,
+            defs,
+            bgRect,
+            webkitRect;
+        if (!me.el) {
+            width = me.width || 0;
+            height = me.height || 0;
+            el = me.createSvgElement('svg', {
+                xmlns: "http:/" + "/www.w3.org/2000/svg",
+                version: 1.1,
+                width: width,
+                height: height
+            });
+            defs = me.getDefs();
+
+            
+            
+            
+            
+            bgRect = me.createSvgElement("rect", {
+                width: "100%",
+                height: "100%",
+                fill: "#000",
+                stroke: "none",
+                opacity: 0
+            });
+            
+            if (Ext.isSafari3) {
+                
+                webkitRect = me.createSvgElement("rect", {
+                    x: -10,
+                    y: -10,
+                    width: "110%",
+                    height: "110%",
+                    fill: "none",
+                    stroke: "#000"
+                });
+            }
+            el.appendChild(defs);
+            if (Ext.isSafari3) {
+                el.appendChild(webkitRect);
+            }
+            el.appendChild(bgRect);
+            container.appendChild(el);
+            me.el = Ext.get(el);
+            me.bgRect = Ext.get(bgRect);
+            if (Ext.isSafari3) {
+                me.webkitRect = Ext.get(webkitRect);
+                me.webkitRect.hide();
+            }
+            me.el.on({
+                scope: me,
+                mouseup: me.onMouseUp,
+                mousedown: me.onMouseDown,
+                mouseover: me.onMouseOver,
+                mouseout: me.onMouseOut,
+                mousemove: me.onMouseMove,
+                mouseenter: me.onMouseEnter,
+                mouseleave: me.onMouseLeave,
+                click: me.onClick,
+                dblclick: me.onDblClick
+            });
+        }
+        me.renderAll();
+    },
+
+    
+    onMouseEnter: function(e) {
+        if (this.el.parent().getRegion().contains(e.getPoint())) {
+            this.fireEvent('mouseenter', e);
+        }
+    },
+
+    
+    onMouseLeave: function(e) {
+        if (!this.el.parent().getRegion().contains(e.getPoint())) {
+            this.fireEvent('mouseleave', e);
+        }
+    },
+    
+    processEvent: function(name, e) {
+        var target = e.getTarget(),
+            surface = this.surface,
+            sprite;
+
+        this.fireEvent(name, e);
+        
+        if (target.nodeName == "tspan" && target.parentNode) {
+            target = target.parentNode;
+        }
+        sprite = this.items.get(target.id);
+        if (sprite) {
+            sprite.fireEvent(name, sprite, e);
+        }
+    },
+
+    
+    tuneText: function (sprite, attrs) {
+        var el = sprite.el.dom,
+            tspans = [],
+            height, tspan, text, i, ln, texts, factor, x;
+
+        if (attrs.hasOwnProperty("text")) {
+            
+            
+            
+
+            
+            text = sprite.tspans && Ext.Array.map(sprite.tspans, function(t) { return t.textContent; }).join('');
+
+            if (!sprite.tspans || attrs.text != text) {
+                tspans = this.setText(sprite, attrs.text);
+                sprite.tspans = tspans;
+            
+            } else {
+                tspans = sprite.tspans || [];
+            }
+        }
+        
+        if (tspans.length) {
+            height = this.getBBoxText(sprite).height;
+            x = sprite.el.dom.getAttribute("x");
+            for (i = 0, ln = tspans.length; i < ln; i++) {
+                
+                
+                factor = (Ext.isFF3_0 || Ext.isFF3_5) ? 2 : 4;
+                tspans[i].setAttribute("x", x);
+                tspans[i].setAttribute("dy", i ? height * 1.2 : height / factor);
+            }
+            sprite.dirty = true;
+        }
+    },
+
+    setText: function(sprite, textString) {
+         var me = this,
+             el = sprite.el.dom,
+             tspans = [],
+             height, tspan, text, i, ln, texts;
+        
+        while (el.firstChild) {
+            el.removeChild(el.firstChild);
+        }
+        
+        texts = String(textString).split("\n");
+        for (i = 0, ln = texts.length; i < ln; i++) {
+            text = texts[i];
+            if (text) {
+                tspan = me.createSvgElement("tspan");
+                tspan.appendChild(document.createTextNode(Ext.htmlDecode(text)));
+                el.appendChild(tspan);
+                tspans[i] = tspan;
+            }
+        }
+        return tspans;
+    },
+
+    renderAll: function() {
+        this.items.each(this.renderItem, this);
+    },
+
+    renderItem: function (sprite) {
+        if (!this.el) {
+            return;
+        }
+        if (!sprite.el) {
+            this.createSpriteElement(sprite);
+        }
+        if (sprite.zIndexDirty) {
+            this.applyZIndex(sprite);
+        }
+        if (sprite.dirty) {
+            this.applyAttrs(sprite);
+            if (sprite.dirtyTransform) {
+                this.applyTransformations(sprite);
+            }
+        }
+    },
+
+    redraw: function(sprite) {
+        sprite.dirty = sprite.zIndexDirty = true;
+        this.renderItem(sprite);
+    },
+
+    applyAttrs: function (sprite) {
+        var me = this,
+            el = sprite.el,
+            group = sprite.group,
+            sattr = sprite.attr,
+            parsers = me.parsers,
+            
+            
+            
+            gradientsMap = me.gradientsMap || {},
+            safariFix = Ext.isSafari && !Ext.isStrict,
+            groups, i, ln, attrs, font, key, style, name, rect;
+
+        if (group) {
+            groups = [].concat(group);
+            ln = groups.length;
+            for (i = 0; i < ln; i++) {
+                group = groups[i];
+                me.getGroup(group).add(sprite);
+            }
+            delete sprite.group;
+        }
+        attrs = me.scrubAttrs(sprite) || {};
+
+        
+            sprite.bbox.plain = 0;
+            sprite.bbox.transform = 0;
+            if (sprite.type == "circle" || sprite.type == "ellipse") {
+                attrs.cx = attrs.cx || attrs.x;
+                attrs.cy = attrs.cy || attrs.y;
+            }
+            else if (sprite.type == "rect") {
+                attrs.rx = attrs.ry = attrs.r;
+            }
+            else if (sprite.type == "path" && attrs.d) {
+                attrs.d = Ext.draw.Draw.pathToString(Ext.draw.Draw.pathToAbsolute(attrs.d));
+            }
+            sprite.dirtyPath = false;
+        
+        
+        
+        
+
+        if (attrs['clip-rect']) {
+            me.setClip(sprite, attrs);
+            delete attrs['clip-rect'];
+        }
+        if (sprite.type == 'text' && attrs.font && sprite.dirtyFont) {
+            el.set({ style: "font: " + attrs.font});
+        }
+        if (sprite.type == "image") {
+            el.dom.setAttributeNS(me.xlink, "href", attrs.src);
+        }
+        Ext.applyIf(attrs, me.minDefaults[sprite.type]);
+
+        if (sprite.dirtyHidden) {
+            (sattr.hidden) ? me.hidePrim(sprite) : me.showPrim(sprite);
+            sprite.dirtyHidden = false;
+        }
+        for (key in attrs) {
+            if (attrs.hasOwnProperty(key) && attrs[key] != null) {
+                
+                
+                
+                
+                
+                if (safariFix && ('color|stroke|fill'.indexOf(key) > -1) && (attrs[key] in gradientsMap)) {
+                    attrs[key] = gradientsMap[attrs[key]];
+                }
+                
+                if (key == 'hidden' && sprite.type == 'text') {
+                    continue;
+                }
+                if (key in parsers) {
+                    el.dom.setAttribute(key, parsers[key](attrs[key], sprite, me));
+                } else {
+                    el.dom.setAttribute(key, attrs[key]);
+                }
+            }
+        }
+        
+        if (sprite.type == 'text') {
+            me.tuneText(sprite, attrs);
+        }
+        sprite.dirtyFont = false;
+
+        
+        style = sattr.style;
+        if (style) {
+            el.setStyle(style);
+        }
+
+        sprite.dirty = false;
+
+        if (Ext.isSafari3) {
+            
+            me.webkitRect.show();
+            setTimeout(function () {
+                me.webkitRect.hide();
+            });
+        }
+    },
+
+    setClip: function(sprite, params) {
+        var me = this,
+            rect = params["clip-rect"],
+            clipEl, clipPath;
+        if (rect) {
+            if (sprite.clip) {
+                sprite.clip.parentNode.parentNode.removeChild(sprite.clip.parentNode);
+            }
+            clipEl = me.createSvgElement('clipPath');
+            clipPath = me.createSvgElement('rect');
+            clipEl.id = Ext.id(null, 'ext-clip-');
+            clipPath.setAttribute("x", rect.x);
+            clipPath.setAttribute("y", rect.y);
+            clipPath.setAttribute("width", rect.width);
+            clipPath.setAttribute("height", rect.height);
+            clipEl.appendChild(clipPath);
+            me.getDefs().appendChild(clipEl);
+            sprite.el.dom.setAttribute("clip-path", "url(#" + clipEl.id + ")");
+            sprite.clip = clipPath;
+        } 
+        
+        
+        
+        
+        
+        
+    },
+
+    
+    applyZIndex: function(sprite) {
+        var me = this,
+            items = me.items,
+            idx = items.indexOf(sprite),
+            el = sprite.el,
+            prevEl;
+        if (me.el.dom.childNodes[idx + 2] !== el.dom) { 
+            if (idx > 0) {
+                
+                do {
+                    prevEl = items.getAt(--idx).el;
+                } while (!prevEl && idx > 0);
+            }
+            el.insertAfter(prevEl || me.bgRect);
+        }
+        sprite.zIndexDirty = false;
+    },
+
+    createItem: function (config) {
+        var sprite = new Ext.draw.Sprite(config);
+        sprite.surface = this;
+        return sprite;
+    },
+
+    addGradient: function(gradient) {
+        gradient = Ext.draw.Draw.parseGradient(gradient);
+        var me = this,
+            ln = gradient.stops.length,
+            vector = gradient.vector,
+            
+            
+            
+            usePlain = Ext.isSafari && !Ext.isStrict,
+            gradientEl, stop, stopEl, i, gradientsMap;
+            
+        gradientsMap = me.gradientsMap || {};
+        
+        if (!usePlain) {
+            if (gradient.type == "linear") {
+                gradientEl = me.createSvgElement("linearGradient");
+                gradientEl.setAttribute("x1", vector[0]);
+                gradientEl.setAttribute("y1", vector[1]);
+                gradientEl.setAttribute("x2", vector[2]);
+                gradientEl.setAttribute("y2", vector[3]);
+            }
+            else {
+                gradientEl = me.createSvgElement("radialGradient");
+                gradientEl.setAttribute("cx", gradient.centerX);
+                gradientEl.setAttribute("cy", gradient.centerY);
+                gradientEl.setAttribute("r", gradient.radius);
+                if (Ext.isNumber(gradient.focalX) && Ext.isNumber(gradient.focalY)) {
+                    gradientEl.setAttribute("fx", gradient.focalX);
+                    gradientEl.setAttribute("fy", gradient.focalY);
+                }
+            }
+            gradientEl.id = gradient.id;
+            me.getDefs().appendChild(gradientEl);
+            for (i = 0; i < ln; i++) {
+                stop = gradient.stops[i];
+                stopEl = me.createSvgElement("stop");
+                stopEl.setAttribute("offset", stop.offset + "%");
+                stopEl.setAttribute("stop-color", stop.color);
+                stopEl.setAttribute("stop-opacity",stop.opacity);
+                gradientEl.appendChild(stopEl);
+            }
+        } else {
+            gradientsMap['url(#' + gradient.id + ')'] = gradient.stops[0].color;
+        }
+        me.gradientsMap = gradientsMap;
+    },
+
+    
+    hasCls: function(sprite, className) {
+        return className && (' ' + (sprite.el.dom.getAttribute('class') || '') + ' ').indexOf(' ' + className + ' ') != -1;
+    },
+
+    addCls: function(sprite, className) {
+        var el = sprite.el,
+            i,
+            len,
+            v,
+            cls = [],
+            curCls =  el.getAttribute('class') || '';
+        
+        if (!Ext.isArray(className)) {
+            if (typeof className == 'string' && !this.hasCls(sprite, className)) {
+                el.set({ 'class': curCls + ' ' + className });
+            }
+        }
+        else {
+            for (i = 0, len = className.length; i < len; i++) {
+                v = className[i];
+                if (typeof v == 'string' && (' ' + curCls + ' ').indexOf(' ' + v + ' ') == -1) {
+                    cls.push(v);
+                }
+            }
+            if (cls.length) {
+                el.set({ 'class': ' ' + cls.join(' ') });
+            }
+        }
+    },
+
+    removeCls: function(sprite, className) {
+        var me = this,
+            el = sprite.el,
+            curCls =  el.getAttribute('class') || '',
+            i, idx, len, cls, elClasses;
+        if (!Ext.isArray(className)){
+            className = [className];
+        }
+        if (curCls) {
+            elClasses = curCls.replace(me.trimRe, ' ').split(me.spacesRe);
+            for (i = 0, len = className.length; i < len; i++) {
+                cls = className[i];
+                if (typeof cls == 'string') {
+                    cls = cls.replace(me.trimRe, '');
+                    idx = Ext.Array.indexOf(elClasses, cls);
+                    if (idx != -1) {
+                        Ext.Array.erase(elClasses, idx, 1);
+                    }
+                }
+            }
+            el.set({ 'class': elClasses.join(' ') });
+        }
+    },
+
+    destroy: function() {
+        var me = this;
+        
+        me.callParent();
+        if (me.el) {
+            me.el.remove();
+        }
+        if (me._defs) {
+            Ext.get(me._defs).destroy();
+        }
+        if (me.bgRect) {
+            Ext.get(me.bgRect).destroy();
+        }
+        if (me.webkitRect) {
+            Ext.get(me.webkitRect).destroy();
+        }
+        delete me.el;
+    }
+});
+
+
+Ext.define('Ext.draw.engine.SvgExporter', function(){
+   var commaRe = /,/g,
+       fontRegex = /(-?\d*\.?\d*){1}(em|ex|px|in|cm|mm|pt|pc|%)\s('*.*'*)/,
+       rgbColorRe = /rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)/g,
+       rgbaColorRe = /rgba\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,([\d\.]+)\)/g,
+       surface, len, width, height,
+
+   init = function(s){
+       surface = s;
+       len = surface.length;
+       width = surface.width;
+       height = surface.height;
+   },
+   spriteProcessor = {
+       path: function(sprite){
+
+           var attr = sprite.attr,
+               path = attr.path,
+               pathString = '',
+               props, p, pLen;
+
+           if (Ext.isArray(path[0])) {
+               pLen = path.length;
+               for (p = 0; p < pLen; p++) {
+                   pathString += path[p].join(' ');
+               }
+           } else if (Ext.isArray(path)) {
+               pathString = path.join(' ');
+           } else {
+               pathString = path.replace(commaRe,' ');
+           }
+
+           props = toPropertyString({
+               d: pathString,
+               fill: attr.fill || 'none',
+               stroke: attr.stroke,
+               'fill-opacity': attr.opacity,
+               'stroke-width': attr['stroke-width'],
+               'stroke-opacity': attr['stroke-opacity'],
+               "z-index": attr.zIndex,
+               transform: sprite.matrix.toSvg()
+           });
+
+           return '<path ' + props + '/>';
+       },
+       text: function(sprite){
+
+           
+           
+
+           var attr = sprite.attr,
+               match = fontRegex.exec(attr.font),
+               size = (match && match[1]) || "12",
+               
+               family = (match && match[3]) || 'Arial',
+               text = attr.text,
+               factor = (Ext.isFF3_0 || Ext.isFF3_5) ? 2 : 4,
+               tspanString = '',
+               props;
+
+           sprite.getBBox();
+           tspanString += '<tspan x="' + (attr.x || '') + '" dy="';
+           tspanString += (size/factor)+'">';
+           tspanString += Ext.htmlEncode(text) + '</tspan>';
+
+
+           props = toPropertyString({
+               x: attr.x,
+               y: attr.y,
+               'font-size': size,
+               'font-family': family,
+               'font-weight': attr['font-weight'],
+               'text-anchor': attr['text-anchor'],
+               
+               fill: attr.fill || '#000',
+               'fill-opacity': attr.opacity,
+               transform: sprite.matrix.toSvg()
+           });
+
+
+
+           return '<text '+ props + '>' +  tspanString + '</text>';
+       },
+       rect: function(sprite){
+
+           var attr = sprite.attr,
+               props =  toPropertyString({
+                   x: attr.x,
+                   y: attr.y,
+                   rx: attr.rx,
+                   ry: attr.ry,
+                   width: attr.width,
+                   height: attr.height,
+                   fill: attr.fill || 'none',
+                   'fill-opacity': attr.opacity,
+                   stroke: attr.stroke,
+                   'stroke-opacity': attr['stroke-opacity'],
+                   'stroke-width':attr['stroke-width'],
+                   transform: sprite.matrix && sprite.matrix.toSvg()
+               });
+
+           return '<rect ' + props + '/>';
+       },
+       circle: function(sprite){
+
+           var attr = sprite.attr,
+               props = toPropertyString({
+                   cx: attr.x,
+                   cy: attr.y,
+                   r: attr.radius,
+                   fill: attr.translation.fill || attr.fill || 'none',
+                   'fill-opacity': attr.opacity,
+                   stroke: attr.stroke,
+                   'stroke-opacity': attr['stroke-opacity'],
+                   'stroke-width':attr['stroke-width'],
+                   transform: sprite.matrix.toSvg()
+               });
+
+           return '<circle ' + props + ' />';
+       },
+       image: function(sprite){
+
+           var attr = sprite.attr,
+               props = toPropertyString({
+                   x: attr.x - (attr.width/2 >> 0),
+                   y: attr.y - (attr.height/2 >> 0),
+                   width: attr.width,
+                   height: attr.height,
+                   'xlink:href': attr.src,
+                   transform: sprite.matrix.toSvg()
+               });
+
+           return '<image ' + props + ' />';
+       }
+   },
+   svgHeader = function(){
+       var svg = '<?xml version="1.0" standalone="yes"?>';
+       svg += '<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">';
+       return svg;
+   },
+   svgContent = function(){
+       var svg = '<svg width="'+width+'px" height="'+height+'px" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1">',
+           defs = '', item, itemsLen, items, gradient,
+           getSvgString, colorstops, stop,
+           coll, keys, colls, k, kLen, key, collI, i, j, stopsLen, sortedItems, za, zb;
+
+       items = surface.items.items;
+       itemsLen = items.length;
+
+
+       getSvgString = function(node){
+
+           var childs = node.childNodes,
+               childLength = childs.length,
+               i = 0,
+               attrLength,
+               j,
+               svgString = '', child, attr, tagName, attrItem;
+
+               for(; i < childLength; i++){
+                   child = childs[i];
+                   attr = child.attributes;
+                   tagName = child.tagName;
+
+                   svgString += '<' +tagName;
+
+                   for(j = 0, attrLength = attr.length; j < attrLength; j++){
+                       attrItem = attr.item(j);
+                       svgString += ' '+attrItem.name+'="'+attrItem.value+'"';
+                   }
+
+                   svgString += '>';
+
+                   if(child.childNodes.length > 0){
+                       svgString += getSvgString(child);
+                   }
+
+                   svgString += '</' + tagName + '>';
+
+               }
+           return svgString;
+       };
+
+
+       if(surface.getDefs){
+           defs = getSvgString(surface.getDefs());
+       }else{
+           
+           coll = surface.gradientsColl;
+           if (coll) {
+               keys  = coll.keys;
+               colls = coll.items;
+               k     = 0;
+               kLen  = keys.length;
+           }
+
+           for (; k < kLen; k++) {
+               key   = keys[k];
+               collI = colls[k];
+
+               gradient = surface.gradientsColl.getByKey(key);
+               defs += '<linearGradient id="' + key + '" x1="0" y1="0" x2="1" y2="1">';
+
+               var color = gradient.colors.replace(rgbColorRe, 'rgb($1|$2|$3)');
+               color = color.replace(rgbaColorRe, 'rgba($1|$2|$3|$4)')
+               colorstops = color.split(',');
+               for(i=0, stopsLen = colorstops.length; i < stopsLen; i++){
+                   stop = colorstops[i].split(' ');
+                   color = Ext.draw.Color.fromString(stop[1].replace(/\|/g,','));
+                   defs += '<stop offset="'+stop[0]+'" stop-color="' + color.toString() + '" stop-opacity="1"></stop>';
+               }
+               defs += '</linearGradient>';
+           }
+       }
+
+       svg += '<defs>' + defs + '</defs>';
+
+       
+       svg += spriteProcessor.rect({
+           attr: {
+                   width: '100%',
+                   height: '100%',
+                   fill: '#fff',
+                   stroke: 'none',
+                   opacity: '0'
+           }
+       });
+
+       
+       sortedItems = new Array(itemsLen);
+       for(i = 0; i < itemsLen; i++){
+           sortedItems[i] = i;
+       }
+       sortedItems.sort(function (a, b) {
+           za = items[a].attr.zIndex || 0;
+           zb = items[b].attr.zIndex || 0;
+           if (za == zb) {
+               return a - b;
+           }
+           return za - zb;
+       });
+
+       for(i = 0; i < itemsLen; i++){
+           item = items[sortedItems[i]];
+           if(!item.attr.hidden){
+               svg += spriteProcessor[item.type](item);
+           }
+       }
+
+       svg += '</svg>';
+
+       return svg;
+   },
+   toPropertyString = function(obj){
+       var propString = '',
+           key;
+
+       for(key in obj){
+
+           if(obj.hasOwnProperty(key) && obj[key] != null){
+               propString += key +'="'+ obj[key]+'" ';
+           }
+
+       }
+
+       return propString;
+   };
+
+   return {
+       singleton: true,
+
+       
+       generate: function(surface, config){
+           config = config || {};
+           init(surface);
+           return svgHeader() + svgContent();
+       }
+   };
+});
+
+
+Ext.define('Ext.draw.engine.Vml', {
+
+    
+
+    extend: 'Ext.draw.Surface',
+
+    requires: ['Ext.draw.Draw', 'Ext.draw.Color', 'Ext.draw.Sprite', 'Ext.draw.Matrix', 'Ext.Element'],
+
+    
+
+    engine: 'Vml',
+
+    map: {M: "m", L: "l", C: "c", Z: "x", m: "t", l: "r", c: "v", z: "x"},
+    bitesRe: /([clmz]),?([^clmz]*)/gi,
+    valRe: /-?[^,\s\-]+/g,
+    fillUrlRe: /^url\(\s*['"]?([^\)]+?)['"]?\s*\)$/i,
+    pathlike: /^(path|rect)$/,
+    NonVmlPathRe: /[ahqstv]/ig, // Non-VML Pathing ops
+    partialPathRe: /[clmz]/g,
+    fontFamilyRe: /^['"]+|['"]+$/g,
+    baseVmlCls: Ext.baseCSSPrefix + 'vml-base',
+    vmlGroupCls: Ext.baseCSSPrefix + 'vml-group',
+    spriteCls: Ext.baseCSSPrefix + 'vml-sprite',
+    measureSpanCls: Ext.baseCSSPrefix + 'vml-measure-span',
+    zoom: 21600,
+    coordsize: 1000,
+    coordorigin: '0 0',
+    zIndexShift: 0,
+    // VML uses CSS z-index and therefore doesn't need sprites to be kept in zIndex order
+    orderSpritesByZIndex: false,
+
+    
+    
+    path2vml: function (path) {
+        var me = this,
+            nonVML = me.NonVmlPathRe,
+            map = me.map,
+            val = me.valRe,
+            zoom = me.zoom,
+            bites = me.bitesRe,
+            command = Ext.Function.bind(Ext.draw.Draw.pathToAbsolute, Ext.draw.Draw),
+            res, pa, p, r, i, ii, j, jj;
+        if (String(path).match(nonVML)) {
+            command = Ext.Function.bind(Ext.draw.Draw.path2curve, Ext.draw.Draw);
+        } else if (!String(path).match(me.partialPathRe)) {
+            res = String(path).replace(bites, function (all, command, args) {
+                var vals = [],
+                    isMove = command.toLowerCase() == "m",
+                    res = map[command];
+                args.replace(val, function (value) {
+                    if (isMove && vals.length === 2) {
+                        res += vals + map[command == "m" ? "l" : "L"];
+                        vals = [];
+                    }
+                    vals.push(Math.round(value * zoom));
+                });
+                return res + vals;
+            });
+            return res;
+        }
+        pa = command(path);
+        res = [];
+        for (i = 0, ii = pa.length; i < ii; i++) {
+            p = pa[i];
+            r = pa[i][0].toLowerCase();
+            if (r == "z") {
+                r = "x";
+            }
+            for (j = 1, jj = p.length; j < jj; j++) {
+                r += Math.round(p[j] * me.zoom) + (j != jj - 1 ? "," : "");
+            }
+            res.push(r);
+        }
+        return res.join(" ");
+    },
+
+    
+    translateAttrs: {
+        radius: "r",
+        radiusX: "rx",
+        radiusY: "ry",
+        lineWidth: "stroke-width",
+        fillOpacity: "fill-opacity",
+        strokeOpacity: "stroke-opacity",
+        strokeLinejoin: "stroke-linejoin"
+    },
+
+    
+    minDefaults: {
+        circle: {
+            fill: "none",
+            stroke: null,
+            "stroke-width": null,
+            opacity: null,
+            "fill-opacity": null,
+            "stroke-opacity": null
+        },
+        ellipse: {
+            cx: 0,
+            cy: 0,
+            rx: 0,
+            ry: 0,
+            fill: "none",
+            stroke: null,
+            "stroke-width": null,
+            opacity: null,
+            "fill-opacity": null,
+            "stroke-opacity": null
+        },
+        rect: {
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0,
+            rx: 0,
+            ry: 0,
+            fill: "none",
+            stroke: null,
+            "stroke-width": null,
+            opacity: null,
+            "fill-opacity": null,
+            "stroke-opacity": null
+        },
+        text: {
+            x: 0,
+            y: 0,
+            "text-anchor": "start",
+            font: '10px "Arial"',
+            fill: "#000",
+            stroke: null,
+            "stroke-width": null,
+            opacity: null,
+            "fill-opacity": null,
+            "stroke-opacity": null
+        },
+        path: {
+            d: "M0,0",
+            fill: "none",
+            stroke: null,
+            "stroke-width": null,
+            opacity: null,
+            "fill-opacity": null,
+            "stroke-opacity": null
+        },
+        image: {
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0,
+            preserveAspectRatio: "none",
+            opacity: null
+        }
+    },
+
+    
+    onMouseEnter: function (e) {
+        this.fireEvent("mouseenter", e);
+    },
+
+    
+    onMouseLeave: function (e) {
+        this.fireEvent("mouseleave", e);
+    },
+
+    
+    processEvent: function (name, e) {
+        var target = e.getTarget(),
+            surface = this.surface,
+            sprite;
+        this.fireEvent(name, e);
+        sprite = this.items.get(target.id);
+        if (sprite) {
+            sprite.fireEvent(name, sprite, e);
+        }
+    },
+
+    
+    createSpriteElement: function (sprite) {
+        var me = this,
+            attr = sprite.attr,
+            type = sprite.type,
+            zoom = me.zoom,
+            vml = sprite.vml || (sprite.vml = {}),
+            round = Math.round,
+            el = (type === 'image') ? me.createNode('image') : me.createNode('shape'),
+            path, skew, textPath;
+
+        el.coordsize = zoom + ' ' + zoom;
+        el.coordorigin = attr.coordorigin || "0 0";
+        Ext.get(el).addCls(me.spriteCls);
+        if (type == "text") {
+            vml.path = path = me.createNode("path");
+            path.textpathok = true;
+            vml.textpath = textPath = me.createNode("textpath");
+            textPath.on = true;
+            el.appendChild(textPath);
+            el.appendChild(path);
+        }
+        el.id = sprite.id;
+        sprite.el = Ext.get(el);
+        sprite.el.setStyle('zIndex', -me.zIndexShift);
+        me.el.appendChild(el);
+        if (type !== 'image') {
+            skew = me.createNode("skew");
+            skew.on = true;
+            el.appendChild(skew);
+            sprite.skew = skew;
+        }
+        sprite.matrix = new Ext.draw.Matrix();
+        sprite.bbox = {
+            plain: null,
+            transform: null
+        };
+
+        this.applyAttrs(sprite);
+        this.applyTransformations(sprite);        
+        sprite.fireEvent("render", sprite);
+        return sprite.el;
+    },
+
+    getBBoxText: function (sprite) {
+        var vml = sprite.vml;
+        return {
+            x: vml.X + (vml.bbx || 0) - vml.W / 2,
+            y: vml.Y - vml.H / 2,
+            width: vml.W,
+            height: vml.H
+        };
+    },
+
+    applyAttrs: function (sprite) {
+        var me = this,
+            vml = sprite.vml,
+            group = sprite.group,
+            spriteAttr = sprite.attr,
+            el = sprite.el,
+            dom = el.dom,
+            style, name, groups, i, ln, scrubbedAttrs, font, key,
+            cx, cy, rx, ry;
+
+        if (group) {
+            groups = [].concat(group);
+            ln = groups.length;
+            for (i = 0; i < ln; i++) {
+                group = groups[i];
+                me.getGroup(group).add(sprite);
+            }
+            delete sprite.group;
+        }
+        scrubbedAttrs = me.scrubAttrs(sprite) || {};
+
+        if (sprite.zIndexDirty) {
+            me.setZIndex(sprite);
+        }
+
+        
+        Ext.applyIf(scrubbedAttrs, me.minDefaults[sprite.type]);
+
+        if (sprite.type == 'image') {
+            Ext.apply(sprite.attr, {
+                x: scrubbedAttrs.x,
+                y: scrubbedAttrs.y,
+                width: scrubbedAttrs.width,
+                height: scrubbedAttrs.height
+            });
+            el.setStyle({
+                width: scrubbedAttrs.width + 'px',
+                height: scrubbedAttrs.height + 'px'
+            });
+            dom.src = scrubbedAttrs.src;
+        }
+
+        if (dom.href) {
+            dom.href = scrubbedAttrs.href;
+        }
+        if (dom.title) {
+            dom.title = scrubbedAttrs.title;
+        }
+        if (dom.target) {
+            dom.target = scrubbedAttrs.target;
+        }
+        if (dom.cursor) {
+            dom.cursor = scrubbedAttrs.cursor;
+        }
+
+        
+        if (sprite.dirtyHidden) {
+            (scrubbedAttrs.hidden) ? me.hidePrim(sprite) : me.showPrim(sprite);
+            sprite.dirtyHidden = false;
+        }
+
+        
+        if (sprite.dirtyPath) {
+            if (sprite.type == "circle" || sprite.type == "ellipse") {
+                cx = scrubbedAttrs.x;
+                cy = scrubbedAttrs.y;
+                rx = scrubbedAttrs.rx || scrubbedAttrs.r || 0;
+                ry = scrubbedAttrs.ry || scrubbedAttrs.r || 0;
+                dom.path = Ext.String.format("ar{0},{1},{2},{3},{4},{1},{4},{1}",
+                    Math.round((cx - rx) * me.zoom),
+                    Math.round((cy - ry) * me.zoom),
+                    Math.round((cx + rx) * me.zoom),
+                    Math.round((cy + ry) * me.zoom),
+                    Math.round(cx * me.zoom));
+                sprite.dirtyPath = false;
+            }
+            else if (sprite.type !== "text" && sprite.type !== 'image') {
+                sprite.attr.path = scrubbedAttrs.path = me.setPaths(sprite, scrubbedAttrs) || scrubbedAttrs.path;
+                dom.path = me.path2vml(scrubbedAttrs.path);
+                sprite.dirtyPath = false;
+            }
+        }
+
+        
+        if ("clip-rect" in scrubbedAttrs) {
+            me.setClip(sprite, scrubbedAttrs);
+        }
+
+        
+        if (sprite.type == "text") {
+            me.setTextAttributes(sprite, scrubbedAttrs);
+        }
+
+        
+        if (scrubbedAttrs.opacity || scrubbedAttrs['stroke-opacity'] || scrubbedAttrs.fill) {
+            me.setFill(sprite, scrubbedAttrs);
+        }
+
+        
+        if (scrubbedAttrs.stroke || scrubbedAttrs['stroke-opacity'] || scrubbedAttrs.fill) {
+            me.setStroke(sprite, scrubbedAttrs);
+        }
+
+        
+        style = spriteAttr.style;
+        if (style) {
+            el.setStyle(style);
+        }
+
+        sprite.dirty = false;
+    },
+
+    setZIndex: function (sprite) {
+        var me = this,
+            zIndex = sprite.attr.zIndex,
+            shift = me.zIndexShift,
+            items, iLen, item, i;
+
+        if (zIndex < shift) {
+            
+            
+            items = me.items.items;
+            iLen = items.length;
+
+            for (i = 0; i < iLen; i++) {
+                if ((zIndex = items[i].attr.zIndex) && zIndex < shift) { 
+                    shift = zIndex;
+                }
+            }
+
+            me.zIndexShift = shift;
+            for (i = 0; i < iLen; i++) {
+                item = items[i];
+                if (item.el) {
+                    item.el.setStyle('zIndex', item.attr.zIndex - shift);
+                }
+                item.zIndexDirty = false;
+            }
+        } else if (sprite.el) {
+            sprite.el.setStyle('zIndex', zIndex - shift);
+            sprite.zIndexDirty = false;
+        }
+    },
+
+    
+    setPaths: function (sprite, params) {
+        var spriteAttr = sprite.attr, thickness = sprite.attr['stroke-width'] || 1;
+        
+        sprite.bbox.plain = null;
+        sprite.bbox.transform = null;
+        if (sprite.type == 'circle') {
+            spriteAttr.rx = spriteAttr.ry = params.r;
+            return Ext.draw.Draw.ellipsePath(sprite);
+        }
+        else if (sprite.type == 'ellipse') {
+            spriteAttr.rx = params.rx;
+            spriteAttr.ry = params.ry;
+            return Ext.draw.Draw.ellipsePath(sprite);
+        }
+        else if (sprite.type == 'rect') {
+            spriteAttr.rx = spriteAttr.ry = params.r;
+            return Ext.draw.Draw.rectPath(sprite);
+        }
+        else if (sprite.type == 'path' && spriteAttr.path) {
+            return Ext.draw.Draw.pathToAbsolute(spriteAttr.path);
+        }
+        return false;
+    },
+
+    setFill: function (sprite, params) {
+        var me = this,
+            el = sprite.el.dom,
+            fillEl = el.fill,
+            newfill = false,
+            opacity, gradient, fillUrl, rotation, angle;
+
+        if (!fillEl) {
+            
+            fillEl = el.fill = me.createNode("fill");
+            newfill = true;
+        }
+        if (Ext.isArray(params.fill)) {
+            params.fill = params.fill[0];
+        }
+        if (params.fill == "none") {
+            fillEl.on = false;
+        }
+        else {
+            if (typeof params.opacity == "number") {
+                fillEl.opacity = params.opacity;
+            }
+            if (typeof params["fill-opacity"] == "number") {
+                fillEl.opacity = params["fill-opacity"];
+            }
+            fillEl.on = true;
+            if (typeof params.fill == "string") {
+                fillUrl = params.fill.match(me.fillUrlRe);
+                if (fillUrl) {
+                    fillUrl = fillUrl[1];
+                    
+                    if (fillUrl.charAt(0) == "#") {
+                        gradient = me.gradientsColl.getByKey(fillUrl.substring(1));
+                    }
+                    if (gradient) {
+                        
+                        rotation = params.rotation;
+                        angle = -(gradient.angle + 270 + (rotation ? rotation.degrees : 0)) % 360;
+                        
+                        if (angle === 0) {
+                            angle = 180;
+                        }
+                        fillEl.angle = angle;
+                        fillEl.type = "gradient";
+                        fillEl.method = "sigma";
+                        if (fillEl.colors) {
+                            fillEl.colors.value = gradient.colors;
+                        } else {
+                            fillEl.colors = gradient.colors;
+                        }
+                    }
+                    
+                    else {
+                        fillEl.src = fillUrl;
+                        fillEl.type = "tile";
+                    }
+                }
+                else {
+                    fillEl.color = Ext.draw.Color.toHex(params.fill);
+                    fillEl.src = "";
+                    fillEl.type = "solid";
+                }
+            }
+        }
+        if (newfill) {
+            el.appendChild(fillEl);
+        }
+    },
+
+    setStroke: function (sprite, params) {
+        var me = this,
+            el = sprite.el.dom,
+            strokeEl = sprite.strokeEl,
+            newStroke = false,
+            width, opacity;
+
+        if (!strokeEl) {
+            strokeEl = sprite.strokeEl = me.createNode("stroke");
+            newStroke = true;
+        }
+        if (Ext.isArray(params.stroke)) {
+            params.stroke = params.stroke[0];
+        }
+        if (!params.stroke || params.stroke == "none" || params.stroke == 0 || params["stroke-width"] == 0) {
+            strokeEl.on = false;
+        }
+        else {
+            strokeEl.on = true;
+            if (params.stroke && !params.stroke.match(me.fillUrlRe)) {
+                
+                strokeEl.color = Ext.draw.Color.toHex(params.stroke);
+            }
+            strokeEl.dashstyle = params["stroke-dasharray"] ? "dash" : "solid";
+            strokeEl.joinstyle = params["stroke-linejoin"];
+            strokeEl.endcap = params["stroke-linecap"] || "round";
+            strokeEl.miterlimit = params["stroke-miterlimit"] || 8;
+            width = parseFloat(params["stroke-width"] || 1) * 0.75;
+            opacity = params["stroke-opacity"] || 1;
+            
+            if (Ext.isNumber(width) && width < 1) {
+                strokeEl.weight = 1;
+                strokeEl.opacity = opacity * width;
+            }
+            else {
+                strokeEl.weight = width;
+                strokeEl.opacity = opacity;
+            }
+        }
+        if (newStroke) {
+            el.appendChild(strokeEl);
+        }
+    },
+
+    setClip: function (sprite, params) {
+        var me = this,
+            el = sprite.el,
+            clipEl = sprite.clipEl,
+            rect = String(params["clip-rect"]).split(me.separatorRe);
+        if (!clipEl) {
+            clipEl = sprite.clipEl = me.el.insertFirst(Ext.getDoc().dom.createElement("div"));
+            clipEl.addCls(Ext.baseCSSPrefix + 'vml-sprite');
+        }
+        if (rect.length == 4) {
+            rect[2] = +rect[2] + (+rect[0]);
+            rect[3] = +rect[3] + (+rect[1]);
+            clipEl.setStyle("clip", Ext.String.format("rect({1}px {2}px {3}px {0}px)", rect[0], rect[1], rect[2], rect[3]));
+            clipEl.setSize(me.el.width, me.el.height);
+        }
+        else {
+            clipEl.setStyle("clip", "");
+        }
+    },
+
+    setTextAttributes: function (sprite, params) {
+        var me = this,
+            vml = sprite.vml,
+            textStyle = vml.textpath.style,
+            spanCacheStyle = me.span.style,
+            zoom = me.zoom,
+            round = Math.round,
+            fontObj = {
+                fontSize: "font-size",
+                fontWeight: "font-weight",
+                fontStyle: "font-style"
+            },
+            fontProp,
+            paramProp;
+        if (sprite.dirtyFont) {
+            if (params.font) {
+                textStyle.font = spanCacheStyle.font = params.font;
+            }
+            if (params["font-family"]) {
+                textStyle.fontFamily = '"' + params["font-family"].split(",")[0].replace(me.fontFamilyRe, "") + '"';
+                spanCacheStyle.fontFamily = params["font-family"];
+            }
+
+            for (fontProp in fontObj) {
+                paramProp = params[fontObj[fontProp]];
+                if (paramProp) {
+                    textStyle[fontProp] = spanCacheStyle[fontProp] = paramProp;
+                }
+            }
+
+            me.setText(sprite, params.text);
+
+            if (vml.textpath.string) {
+                me.span.innerHTML = String(vml.textpath.string).replace(/</g, "&#60;").replace(/&/g, "&#38;").replace(/\n/g, "<br/>");
+            }
+            vml.W = me.span.offsetWidth;
+            vml.H = me.span.offsetHeight + 2; 
+
+            
+            if (params["text-anchor"] == "middle") {
+                textStyle["v-text-align"] = "center";
+            }
+            else if (params["text-anchor"] == "end") {
+                textStyle["v-text-align"] = "right";
+                vml.bbx = -Math.round(vml.W / 2);
+            }
+            else {
+                textStyle["v-text-align"] = "left";
+                vml.bbx = Math.round(vml.W / 2);
+            }
+        }
+        vml.X = params.x;
+        vml.Y = params.y;
+        vml.path.v = Ext.String.format("m{0},{1}l{2},{1}", Math.round(vml.X * zoom), Math.round(vml.Y * zoom), Math.round(vml.X * zoom) + 1);
+        
+        sprite.bbox.plain = null;
+        sprite.bbox.transform = null;
+        sprite.dirtyFont = false;
+    },
+
+    setText: function (sprite, text) {
+        sprite.vml.textpath.string = Ext.htmlDecode(text);
+    },
+
+    hide: function () {
+        this.el.hide();
+    },
+
+    show: function () {
+        this.el.show();
+    },
+
+    hidePrim: function (sprite) {
+        sprite.el.addCls(Ext.baseCSSPrefix + 'hide-visibility');
+    },
+
+    showPrim: function (sprite) {
+        sprite.el.removeCls(Ext.baseCSSPrefix + 'hide-visibility');
+    },
+
+    setSize: function (width, height) {
+        var me = this;
+        width = width || me.width;
+        height = height || me.height;
+        me.width = width;
+        me.height = height;
+
+        if (me.el) {
+            
+            if (width != undefined) {
+                me.el.setWidth(width);
+            }
+            if (height != undefined) {
+                me.el.setHeight(height);
+            }
+        }
+
+        me.callParent(arguments);
+    },
+
+    
+    applyViewBox: function () {
+        var me = this,
+            viewBox = me.viewBox,
+            width = me.width,
+            height = me.height,
+            items,
+            iLen,
+            i;
+        
+        me.callParent();
+
+        if (viewBox && (width || height)) {
+            items = me.items.items;
+            iLen = items.length;
+
+            for (i = 0; i < iLen; i++) {
+                me.applyTransformations(items[i]);
+            }
+        }
+    },
+
+    onAdd: function (item) {
+        this.callParent(arguments);
+        if (this.el) {
+            this.renderItem(item);
+        }
+    },
+
+    onRemove: function (sprite) {
+        if (sprite.el) {
+            sprite.el.remove();
+            delete sprite.el;
+        }
+        this.callParent(arguments);
+    },
+
+    render: function (container) {
+        var me = this,
+            doc = Ext.getDoc().dom,
+            el;
+        
+        if (!me.createNode) {
+            try {
+                if (!doc.namespaces.rvml) {
+                    doc.namespaces.add("rvml", "urn:schemas-microsoft-com:vml");
+                }
+                me.createNode = function (tagName) {
+                    return doc.createElement("<rvml:" + tagName + ' class="rvml">');
+                };
+            } catch (e) {
+                me.createNode = function (tagName) {
+                    return doc.createElement("<" + tagName + ' xmlns="urn:schemas-microsoft.com:vml" class="rvml">');
+                };
+            }
+        }
+
+        if (!me.el) {
+            el = doc.createElement("div");
+            me.el = Ext.get(el);
+            me.el.addCls(me.baseVmlCls);
+
+            
+            me.span = doc.createElement("span");
+            Ext.get(me.span).addCls(me.measureSpanCls);
+            el.appendChild(me.span);
+            me.el.setSize(me.width || 0, me.height || 0);
+            container.appendChild(el);
+            me.el.on({
+                scope: me,
+                mouseup: me.onMouseUp,
+                mousedown: me.onMouseDown,
+                mouseover: me.onMouseOver,
+                mouseout: me.onMouseOut,
+                mousemove: me.onMouseMove,
+                mouseenter: me.onMouseEnter,
+                mouseleave: me.onMouseLeave,
+                click: me.onClick,
+                dblclick: me.onDblClick
+            });
+        }
+        me.renderAll();
+    },
+
+    renderAll: function () {
+        this.items.each(this.renderItem, this);
+    },
+
+    redraw: function (sprite) {
+        sprite.dirty = true;
+        this.renderItem(sprite);
+    },
+
+    renderItem: function (sprite) {
+        
+        if (!this.el) {
+            return;
+        }
+
+        
+        if (!sprite.el) {
+            this.createSpriteElement(sprite);
+        }
+
+        if (sprite.dirty) {
+            this.applyAttrs(sprite);
+            if (sprite.dirtyTransform) {
+                this.applyTransformations(sprite);
+            }
+        }
+    },
+
+    rotationCompensation: function (deg, dx, dy) {
+        var matrix = new Ext.draw.Matrix();
+        matrix.rotate(-deg, 0.5, 0.5);
+        return {
+            x: matrix.x(dx, dy),
+            y: matrix.y(dx, dy)
+        };
+    },
+
+    transform: function (sprite, matrixOnly) {
+        var me = this,
+            bbox = me.getBBox(sprite, true),
+            cx = bbox.x + bbox.width * 0.5,
+            cy = bbox.y + bbox.height * 0.5,
+            matrix = new Ext.draw.Matrix(),
+            transforms = sprite.transformations,
+            transformsLength = transforms.length,
+            i = 0,
+            deltaDegrees = 0,
+            deltaScaleX = 1,
+            deltaScaleY = 1,
+            flip = "",
+            el = sprite.el,
+            dom = el.dom,
+            domStyle = dom.style,
+            zoom = me.zoom,
+            skew = sprite.skew,
+            shift = me.viewBoxShift,
+            deltaX, deltaY, transform, type, compensate, y, fill, newAngle, zoomScaleX, zoomScaleY, newOrigin, offset;
+
+
+        for (; i < transformsLength; i++) {
+            transform = transforms[i];
+            type = transform.type;
+            if (type == "translate") {
+                matrix.translate(transform.x, transform.y);
+            }
+            else if (type == "rotate") {
+                matrix.rotate(transform.degrees, transform.x, transform.y);
+                deltaDegrees += transform.degrees;
+            }
+            else if (type == "scale") {
+                matrix.scale(transform.x, transform.y, transform.centerX, transform.centerY);
+                deltaScaleX *= transform.x;
+                deltaScaleY *= transform.y;
+            }
+        }
+
+        sprite.matrix = matrix.clone();
+
+        if (matrixOnly) {
+            return;
+        }
+
+        if (shift) {
+            matrix.prepend(shift.scale, 0, 0, shift.scale, shift.dx * shift.scale, shift.dy * shift.scale);
+        }
+
+        
+        if (sprite.type != "image" && skew) {
+            skew.origin = "0,0";
+            
+            skew.matrix = matrix.toString();
+            
+            
+            
+            offset = matrix.offset();
+            if (offset[0] > 32767) {
+                offset[0] = 32767;
+            } else if (offset[0] < -32768) {
+                offset[0] = -32768;
+            }
+            if (offset[1] > 32767) {
+                offset[1] = 32767;
+            } else if (offset[1] < -32768) {
+                offset[1] = -32768;
+            }
+            skew.offset = offset;
+        }
+        else {
+            domStyle.filter = matrix.toFilter();
+            domStyle.left = Math.min(
+                matrix.x(bbox.x, bbox.y),
+                matrix.x(bbox.x + bbox.width, bbox.y),
+                matrix.x(bbox.x, bbox.y + bbox.height),
+                matrix.x(bbox.x + bbox.width, bbox.y + bbox.height)) + 'px';
+            domStyle.top = Math.min(
+                matrix.y(bbox.x, bbox.y),
+                matrix.y(bbox.x + bbox.width, bbox.y),
+                matrix.y(bbox.x, bbox.y + bbox.height),
+                matrix.y(bbox.x + bbox.width, bbox.y + bbox.height)) + 'px';
+        }
+    },
+
+    createItem: function (config) {
+        return Ext.create('Ext.draw.Sprite', config);
+    },
+
+    getRegion: function () {
+        return this.el.getRegion();
+    },
+
+    addCls: function (sprite, className) {
+        if (sprite && sprite.el) {
+            sprite.el.addCls(className);
+        }
+    },
+
+    removeCls: function (sprite, className) {
+        if (sprite && sprite.el) {
+            sprite.el.removeCls(className);
+        }
+    },
+
+    
+    addGradient: function (gradient) {
+        var gradients = this.gradientsColl || (this.gradientsColl = Ext.create('Ext.util.MixedCollection')),
+            colors = [],
+            stops = Ext.create('Ext.util.MixedCollection'),
+            keys,
+            items,
+            iLen,
+            key,
+            item,
+            i;
+
+        
+        stops.addAll(gradient.stops);
+        stops.sortByKey("ASC", function (a, b) {
+            a = parseInt(a, 10);
+            b = parseInt(b, 10);
+            return a > b ? 1 : (a < b ? -1 : 0);
+        });
+
+        keys = stops.keys;
+        items = stops.items;
+        iLen = keys.length;
+
+        for (i = 0; i < iLen; i++) {
+            key = keys[i];
+            item = items[i];
+            colors.push(key + '% ' + item.color);
+        }
+
+        gradients.add(gradient.id, {
+            colors: colors.join(","),
+            angle: gradient.angle
+        });
+    },
+
+    destroy: function () {
+        var me = this;
+
+        me.callParent(arguments);
+        if (me.el) {
+            me.el.remove();
+        }
+        delete me.el;
+    }
+});
+
+
+Ext.define('Ext.flash.Component', {
+    extend: 'Ext.Component',
+    alternateClassName: 'Ext.FlashComponent',
+    alias: 'widget.flash',
+
+    
+    flashVersion : '9.0.115',
+
+    
+    backgroundColor: '#ffffff',
+
+    
+    wmode: 'opaque',
+
+    
+
+    
+
+    
+
+    
+
+    
+    swfWidth: '100%',
+
+    
+    swfHeight: '100%',
+
+    
+    expressInstall: false,
+
+    
+
+    
+    renderTpl: ['<div id="{swfId}"></div>'],
+
+    initComponent: function() {
+
+        this.callParent();
+        this.addEvents(
+            
+            'success',
+
+            
+            'failure'
+        );
+    },
+    
+    beforeRender: function(){
+        this.callParent();
+        
+        Ext.applyIf(this.renderData, {
+            swfId: this.getSwfId()
+        });
+    },
+
+    afterRender: function() {
+        var me = this,
+            flashParams = Ext.apply({}, me.flashParams), 
+            flashVars = Ext.apply({}, me.flashVars);
+
+        me.callParent();
+
+        flashParams = Ext.apply({
+            allowScriptAccess: 'always',
+            bgcolor: me.backgroundColor,
+            wmode: me.wmode
+        }, flashParams);
+
+        flashVars = Ext.apply({
+            allowedDomain: document.location.hostname
+        }, flashVars);
+
+        new swfobject.embedSWF(
+            me.url,
+            me.getSwfId(),
+            me.swfWidth,
+            me.swfHeight,
+            me.flashVersion,
+            me.expressInstall ? me.statics.EXPRESS_INSTALL_URL : undefined,
+            flashVars,
+            flashParams,
+            me.flashAttributes,
+            Ext.bind(me.swfCallback, me)
+        );
+    },
+
+    
+    swfCallback: function(e) {
+        var me = this;
+        if (e.success) {
+            me.swf = Ext.get(e.ref);
+            me.onSuccess();
+            me.fireEvent('success', me);
+        } else {
+            me.onFailure();
+            me.fireEvent('failure', me);
+        }
+    },
+
+    
+    getSwfId: function() {
+        return this.swfId || (this.swfId = "extswf" + this.getAutoId());
+    },
+
+    onSuccess: function() {
+        
+        
+        this.swf.setStyle('visibility', 'inherit');
+    },
+
+    onFailure: Ext.emptyFn,
+
+    beforeDestroy: function() {
+        var me = this,
+            swf = me.swf;
+        if (swf) {
+            swfobject.removeSWF(me.getSwfId());
+            Ext.destroy(swf);
+            delete me.swf;
+        }
+        me.callParent();
+    },
+
+    statics: {
+        
+        EXPRESS_INSTALL_URL: 'http:/' + '/swfobject.googlecode.com/svn/trunk/swfobject/expressInstall.swf'
+    }
+});
+
+
+Ext.define('Ext.form.action.Action', {
+    alternateClassName: 'Ext.form.Action',
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+    submitEmptyText : true,
+
+    
+
+    
+
+    
+
+    
+
+    
+    constructor: function(config) {
+        if (config) {
+            Ext.apply(this, config);
+        }
+
+        
+        var params = config.params;
+        if (Ext.isString(params)) {
+            this.params = Ext.Object.fromQueryString(params);
+        }
+    },
+
+    
+    run: Ext.emptyFn,
+
+    
+
+    
+
+    
+    onFailure : function(response){
+        this.response = response;
+        this.failureType = Ext.form.action.Action.CONNECT_FAILURE;
+        this.form.afterAction(this, false);
+    },
+
+    
+    processResponse : function(response){
+        this.response = response;
+        if (!response.responseText && !response.responseXML) {
+            return true;
+        }
+        return (this.result = this.handleResponse(response));
+    },
+
+    
+    getUrl: function() {
+        return this.url || this.form.url;
+    },
+
+    
+    getMethod: function() {
+        return (this.method || this.form.method || 'POST').toUpperCase();
+    },
+
+    
+    getParams: function() {
+        return Ext.apply({}, this.params, this.form.baseParams);
+    },
+
+    
+    createCallback: function() {
+        var me = this,
+            undef,
+            form = me.form;
+        return {
+            success: me.onSuccess,
+            failure: me.onFailure,
+            scope: me,
+            timeout: (this.timeout * 1000) || (form.timeout * 1000),
+            upload: form.fileUpload ? me.onSuccess : undef
+        };
+    },
+
+    statics: {
+        
+        CLIENT_INVALID: 'client',
+
+        
+        SERVER_INVALID: 'server',
+
+        
+        CONNECT_FAILURE: 'connect',
+
+        
+        LOAD_FAILURE: 'load'
+
+
+    }
+});
+
+
+Ext.define('Ext.form.action.Load', {
+    extend:'Ext.form.action.Action',
+    requires: ['Ext.data.Connection'],
+    alternateClassName: 'Ext.form.Action.Load',
+    alias: 'formaction.load',
+
+    type: 'load',
+
+    
+    run: function() {
+        Ext.Ajax.request(Ext.apply(
+            this.createCallback(),
+            {
+                method: this.getMethod(),
+                url: this.getUrl(),
+                headers: this.headers,
+                params: this.getParams()
+            }
+        ));
+    },
+
+    
+    onSuccess: function(response){
+        var result = this.processResponse(response),
+            form = this.form;
+        if (result === true || !result.success || !result.data) {
+            this.failureType = Ext.form.action.Action.LOAD_FAILURE;
+            form.afterAction(this, false);
+            return;
+        }
+        form.clearInvalid();
+        form.setValues(result.data);
+        form.afterAction(this, true);
+    },
+
+    
+    handleResponse: function(response) {
+        var reader = this.form.reader,
+            rs, data;
+        if (reader) {
+            rs = reader.read(response);
+            data = rs.records && rs.records[0] ? rs.records[0].data : null;
+            return {
+                success : rs.success,
+                data : data
+            };
+        }
+        return Ext.decode(response.responseText);
+    }
+});
+
+
+
+Ext.define('Ext.form.action.Submit', {
+    extend:'Ext.form.action.Action',
+    alternateClassName: 'Ext.form.Action.Submit',
+    alias: 'formaction.submit',
+
+    type: 'submit',
+
+    
+
+    
+    run : function(){
+        var form = this.form;
+        if (this.clientValidation === false || form.isValid()) {
+            this.doSubmit();
+        } else {
+            
+            this.failureType = Ext.form.action.Action.CLIENT_INVALID;
+            form.afterAction(this, false);
+        }
+    },
+
+    
+    doSubmit: function() {
+        var formEl,
+            ajaxOptions = Ext.apply(this.createCallback(), {
+                url: this.getUrl(),
+                method: this.getMethod(),
+                headers: this.headers
+            });
+
+        
+        
+        if (this.form.hasUpload()) {
+            formEl = ajaxOptions.form = this.buildForm();
+            ajaxOptions.isUpload = true;
+        } else {
+            ajaxOptions.params = this.getParams();
+        }
+
+        Ext.Ajax.request(ajaxOptions);
+
+        if (formEl) {
+            Ext.removeNode(formEl);
+        }
+    },
+
+    
+    getParams: function() {
+        var nope = false,
+            configParams = this.callParent(),
+            fieldParams = this.form.getValues(nope, nope, this.submitEmptyText !== nope);
+        return Ext.apply({}, fieldParams, configParams);
+    },
+
+    
+    buildForm: function() {
+        var fieldsSpec = [],
+            formSpec,
+            formEl,
+            basicForm = this.form,
+            params = this.getParams(),
+            uploadFields = [],
+            fields = basicForm.getFields().items,
+            f,
+            fLen   = fields.length,
+            field, key, value, v, vLen,
+            u, uLen;
+
+        for (f = 0; f < fLen; f++) {
+            field = fields[f];
+
+            if (field.isFileUpload()) {
+                uploadFields.push(field);
+            }
+        }
+
+        function addField(name, val) {
+            fieldsSpec.push({
+                tag: 'input',
+                type: 'hidden',
+                name: name,
+                value: Ext.String.htmlEncode(val)
+            });
+        }
+
+        for (key in params) {
+            if (params.hasOwnProperty(key)) {
+                value = params[key];
+
+                if (Ext.isArray(value)) {
+                    vLen = value.length;
+                    for (v = 0; v < vLen; v++) {
+                        addField(key, value[v]);
+                    }
+                } else {
+                    addField(key, value);
+                }
+            }
+        }
+
+        formSpec = {
+            tag: 'form',
+            action: this.getUrl(),
+            method: this.getMethod(),
+            target: this.target || '_self',
+            style: 'display:none',
+            cn: fieldsSpec
+        };
+
+        
+        if (uploadFields.length) {
+            formSpec.encoding = formSpec.enctype = 'multipart/form-data';
+        }
+
+        
+        formEl = Ext.DomHelper.append(Ext.getBody(), formSpec);
+
+        
+        
+        
+        uLen = uploadFields.length;
+
+        for (u = 0; u < uLen; u++) {
+            field = uploadFields[u];
+            if (field.rendered) { 
+                formEl.appendChild(field.extractFileInput());
+            }
+        }
+
+        return formEl;
+    },
+
+
+
+    
+    onSuccess: function(response) {
+        var form = this.form,
+            success = true,
+            result = this.processResponse(response);
+        if (result !== true && !result.success) {
+            if (result.errors) {
+                form.markInvalid(result.errors);
+            }
+            this.failureType = Ext.form.action.Action.SERVER_INVALID;
+            success = false;
+        }
+        form.afterAction(this, success);
+    },
+
+    
+    handleResponse: function(response) {
+        var form = this.form,
+            errorReader = form.errorReader,
+            rs, errors, i, len, records;
+        if (errorReader) {
+            rs = errorReader.read(response);
+            records = rs.records;
+            errors = [];
+            if (records) {
+                for(i = 0, len = records.length; i < len; i++) {
+                    errors[i] = records[i].data;
+                }
+            }
+            if (errors.length < 1) {
+                errors = null;
+            }
+            return {
+                success : rs.success,
+                errors : errors
+            };
+        }
+        return Ext.decode(response.responseText);
+    }
+});
+
+
+Ext.define('Ext.util.ComponentDragger', {
+    extend: 'Ext.dd.DragTracker',
+
+    
+
+    
+
+    
+
+    autoStart: 500,
+
+    
+    constructor: function(comp, config) {
+        this.comp = comp;
+        this.initialConstrainTo = config.constrainTo;
+        this.callParent([ config ]);
+    },
+
+    onStart: function(e) {
+        var me = this,
+            comp = me.comp;
+
+        
+        this.startPosition = comp.el.getXY();
+
+        
+        
+        if (comp.ghost && !comp.liveDrag) {
+             me.proxy = comp.ghost();
+             me.dragTarget = me.proxy.header.el;
+        }
+
+        
+        if (me.constrain || me.constrainDelegate) {
+            me.constrainTo = me.calculateConstrainRegion();
+        }
+
+        if (comp.beginDrag) {
+            comp.beginDrag();
+        }
+    },
+
+    calculateConstrainRegion: function() {
+        var me = this,
+            comp = me.comp,
+            c = me.initialConstrainTo,
+            delegateRegion,
+            elRegion,
+            dragEl = me.proxy ? me.proxy.el : comp.el,
+            shadowSize = (!me.constrainDelegate && dragEl.shadow && !dragEl.shadowDisabled) ? dragEl.shadow.getShadowSize() : 0;
+
+        
+        if (!(c instanceof Ext.util.Region)) {
+            c =  Ext.fly(c).getViewRegion();
+        }
+
+        
+        if (shadowSize) {
+            c.adjust(shadowSize[0], -shadowSize[1], -shadowSize[2], shadowSize[3]);
+        }
+
+        
+        
+        
+        if (!me.constrainDelegate) {
+            delegateRegion = Ext.fly(me.dragTarget).getRegion();
+            elRegion = dragEl.getRegion();
+
+            c.adjust(
+                delegateRegion.top - elRegion.top,
+                delegateRegion.right - elRegion.right,
+                delegateRegion.bottom - elRegion.bottom,
+                delegateRegion.left - elRegion.left
+            );
+        }
+        return c;
+    },
+
+    
+    onDrag: function(e) {
+        var me = this,
+            comp = (me.proxy && !me.comp.liveDrag) ? me.proxy : me.comp,
+            offset = me.getOffset(me.constrain || me.constrainDelegate ? 'dragTarget' : null);
+
+        comp.setPagePosition(me.startPosition[0] + offset[0], me.startPosition[1] + offset[1]);
+    },
+
+    onEnd: function(e) {
+        var comp = this.comp;
+        if (this.proxy && !comp.liveDrag) {
+            comp.unghost();
+        }
+        if (comp.endDrag) {
+            comp.endDrag();
+        }
+    }
+});
+
+
+Ext.define('Ext.window.Window', {
+    extend: 'Ext.panel.Panel',
+
+    alternateClassName: 'Ext.Window',
+
+    requires: ['Ext.util.ComponentDragger', 'Ext.util.Region', 'Ext.EventManager'],
+
+    alias: 'widget.window',
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+    baseCls: Ext.baseCSSPrefix + 'window',
+
+    
+    resizable: true,
+
+    
+    draggable: true,
+
+    
+    constrain: false,
+
+    
+    constrainHeader: false,
+
+    
+
+    
+    plain: false,
+
+    
+    minimizable: false,
+
+    
+    maximizable: false,
+
+    
+    minHeight: 50,
+
+    
+    minWidth: 50,
+
+    
+    expandOnShow: true,
+
+    
+    collapsible: false,
+
+    
+    closable: true,
+
+    
+    hidden: true,
+
+    
+    autoRender: true,
+
+    
+    hideMode: 'offsets',
+
+    
+    floating: true,
+
+    ariaRole: 'alertdialog',
+
+    itemCls: Ext.baseCSSPrefix + 'window-item',
+    
+    initialAlphaNum: /^[a-z0-9]/,
+
+    overlapHeader: true,
+
+    ignoreHeaderBorderManagement: true,
+
+    
+    alwaysFramed: true,
+
+    
+    isWindow: true,
+
+    
+    initComponent: function() {
+        var me = this;
+        
+        
+        me.frame = false;
+        me.callParent();
+        me.addEvents(
+            
+
+            
+
+            
+            'resize',
+
+            
+            'maximize',
+
+            
+            'minimize',
+
+            
+            'restore'
+        );
+
+        if (me.plain) {
+            me.addClsWithUI('plain');
+        }
+
+        if (me.modal) {
+            me.ariaRole = 'dialog';
+        }
+
+        
+        if (me.floating) {
+            me.on({
+                element: 'el',
+                mousedown: me.onMouseDown,
+                scope: me
+            });
+        }
+
+        me.addStateEvents(['maximize', 'restore', 'resize', 'dragend']);
+    },
+
+    getElConfig: function () {
+        var me = this,
+            elConfig;
+
+        elConfig = me.callParent();
+        elConfig.tabIndex = -1;
+        return elConfig;
+    },
+
+    
+    
+
+    getState: function() {
+        var me = this,
+            state = me.callParent() || {},
+            maximized = !!me.maximized;
+
+        state.maximized = maximized;
+        Ext.apply(state, {
+            size: maximized ? me.restoreSize : me.getSize(),
+            pos: maximized ? me.restorePos : me.getPosition()
+        });
+        return state;
+    },
+
+    applyState: function(state){
+        var me = this;
+
+        if (state) {
+            me.maximized = state.maximized;
+            if (me.maximized) {
+                me.hasSavedRestore = true;
+                me.restoreSize = state.size;
+                me.restorePos = state.pos;
+            } else {
+                Ext.apply(me, {
+                    width: state.size.width,
+                    height: state.size.height,
+                    x: state.pos[0],
+                    y: state.pos[1]
+                });
+            }
+        }
+    },
+
+    
+    onMouseDown: function (e) {
+        var preventFocus;
+            
+        if (this.floating) {
+            if (Ext.fly(e.getTarget()).focusable()) {
+                preventFocus = true;
+            }
+            this.toFront(preventFocus);
+        }
+    },
+
+    
+    onRender: function(ct, position) {
+        var me = this;
+        me.callParent(arguments);
+        me.focusEl = me.el;
+
+        
+        if (me.maximizable) {
+            me.header.on({
+                scope: me,
+                dblclick: me.toggleMaximize
+            });
+        }
+    },
+
+    
+    afterRender: function() {
+        var me = this,
+            keyMap;
+
+        me.callParent();
+
+        
+        if (me.maximized) {
+            me.maximized = false;
+            me.maximize();
+        }
+
+        if (me.closable) {
+            keyMap = me.getKeyMap();
+            keyMap.on(27, me.onEsc, me);
+        } else {
+            keyMap = me.keyMap;
+        }
+        if (keyMap && me.hidden) {
+            keyMap.disable();
+        }
+    },
+
+    
+    initDraggable: function() {
+        var me = this,
+            ddConfig;
+
+        if (!me.header) {
+            me.updateHeader(true);
+        }
+
+        
+        if (me.header) {
+            ddConfig = Ext.applyIf({
+                el: me.el,
+                delegate: '#' + Ext.escapeId(me.header.id)
+            }, me.draggable);
+
+            
+            if (me.constrain || me.constrainHeader) {
+                ddConfig.constrain = me.constrain;
+                ddConfig.constrainDelegate = me.constrainHeader;
+                ddConfig.constrainTo = me.constrainTo || me.container;
+            }
+
+            
+            me.dd = new Ext.util.ComponentDragger(this, ddConfig);
+            me.relayEvents(me.dd, ['dragstart', 'drag', 'dragend']);
+        }
+    },
+
+    
+    onEsc: function(k, e) {
+        
+        if (!Ext.FocusManager || !Ext.FocusManager.enabled || Ext.FocusManager.focusedCmp === this) {
+            e.stopEvent();
+            this.close();
+        }
+    },
+
+    
+    beforeDestroy: function() {
+        var me = this;
+        if (me.rendered) {
+            delete this.animateTarget;
+            me.hide();
+            Ext.destroy(
+                me.keyMap
+            );
+        }
+        me.callParent();
+    },
+
+    
+    addTools: function() {
+        var me = this;
+
+        
+        me.callParent();
+
+        if (me.minimizable) {
+            me.addTool({
+                type: 'minimize',
+                handler: Ext.Function.bind(me.minimize, me, [])
+            });
+        }
+        if (me.maximizable) {
+            me.addTool({
+                type: 'maximize',
+                handler: Ext.Function.bind(me.maximize, me, [])
+            });
+            me.addTool({
+                type: 'restore',
+                handler: Ext.Function.bind(me.restore, me, []),
+                hidden: true
+            });
+        }
+    },
+
+    
+    getFocusEl: function() {
+        return this.getDefaultFocus();
+    },
+
+    
+    getDefaultFocus: function() {
+        var me = this,
+            result,
+            defaultComp = me.defaultButton || me.defaultFocus,
+            selector;
+
+        if (defaultComp !== undefined) {
+            
+            if (Ext.isNumber(defaultComp)) {
+                result = me.query('button')[defaultComp];
+            }
+            
+            else if (Ext.isString(defaultComp)) {
+                selector = defaultComp;
+                
+                
+                if (selector.match(me.initialAlphaNum)) {
+                    result = me.down('#' + selector);
+                }
+                
+                if (!result) {
+                    result = me.down(selector);
+                }
+            }
+            
+            else if (defaultComp.focus) {
+                result = defaultComp;
+            }
+        }
+        return result || me.el;
+    },
+
+    
+    onFocus: function() {
+        var me = this,
+            focusDescendant;
+
+        
+        if ((Ext.FocusManager && Ext.FocusManager.enabled) || ((focusDescendant = me.getDefaultFocus()) === me)) {
+            me.callParent(arguments);
+        } else {
+            focusDescendant.focus();
+        }
+    },
+
+    beforeLayout: function () {
+        var shadow = this.el.shadow;
+
+        this.callParent();
+        if (shadow) {
+            shadow.hide();
+        }
+    },
+
+    onShow: function() {
+        var me = this;
+
+        me.callParent(arguments);
+        if (me.expandOnShow) {
+            me.expand(false);
+        }
+        me.syncMonitorWindowResize();
+
+        if (me.keyMap) {
+            me.keyMap.enable();
+        }
+   },
+
+    
+    doClose: function() {
+        var me = this;
+
+        
+        if (me.hidden) {
+            me.fireEvent('close', me);
+            if (me.closeAction == 'destroy') {
+                this.destroy();
+            }
+        } else {
+            
+            me.hide(me.animateTarget, me.doClose, me);
+        }
+    },
+
+    
+    afterHide: function() {
+        var me = this;
+
+        
+        me.syncMonitorWindowResize();
+
+        
+        if (me.keyMap) {
+            me.keyMap.disable();
+        }
+
+        
+        me.callParent(arguments);
+    },
+
+    
+    onWindowResize: function() {
+        var me = this,
+            sizeModel;
+
+        if (me.maximized) {
+            me.fitContainer();
+        } else {
+            sizeModel = me.getSizeModel();
+            if (sizeModel.width.natural || sizeModel.height.natural) {
+                me.updateLayout();
+            }
+        }
+
+        me.doConstrain();
+    },
+
+    
+    minimize: function() {
+        this.fireEvent('minimize', this);
+        return this;
+    },
+
+    afterCollapse: function() {
+        var me = this;
+
+        if (me.maximizable) {
+            me.tools.maximize.hide();
+            me.tools.restore.hide();
+        }
+        if (me.resizer) {
+            me.resizer.disable();
+        }
+        me.callParent(arguments);
+    },
+
+    afterExpand: function() {
+        var me = this;
+
+        if (me.maximized) {
+            me.tools.restore.show();
+        } else if (me.maximizable) {
+            me.tools.maximize.show();
+        }
+        if (me.resizer) {
+            me.resizer.enable();
+        }
+        me.callParent(arguments);
+    },
+
+    
+    maximize: function() {
+        var me = this;
+
+        if (!me.maximized) {
+            me.expand(false);
+            if (!me.hasSavedRestore) {
+                me.restoreSize = me.getSize();
+                me.restorePos = me.getPosition(true);
+            }
+            if (me.maximizable) {
+                me.tools.maximize.hide();
+                me.tools.restore.show();
+            }
+            me.maximized = true;
+            me.el.disableShadow();
+
+            if (me.dd) {
+                me.dd.disable();
+            }
+            if (me.resizer) {
+                me.resizer.disable();
+            }
+            if (me.collapseTool) {
+                me.collapseTool.hide();
+            }
+            me.el.addCls(Ext.baseCSSPrefix + 'window-maximized');
+            me.container.addCls(Ext.baseCSSPrefix + 'window-maximized-ct');
+
+            me.syncMonitorWindowResize();
+            me.fitContainer();
+            me.fireEvent('maximize', me);
+        }
+        return me;
+    },
+
+    
+    restore: function() {
+        var me = this,
+            tools = me.tools;
+
+        if (me.maximized) {
+            delete me.hasSavedRestore;
+            me.removeCls(Ext.baseCSSPrefix + 'window-maximized');
+
+            
+            if (tools.restore) {
+                tools.restore.hide();
+            }
+            if (tools.maximize) {
+                tools.maximize.show();
+            }
+            if (me.collapseTool) {
+                me.collapseTool.show();
+            }
+
+            me.maximized = false;
+
+            
+            me.setPosition(me.restorePos);
+            me.setSize(me.restoreSize);
+
+            
+            delete me.restorePos;
+            delete me.restoreSize;
+
+            me.el.enableShadow(true);
+
+            
+            if (me.dd) {
+                me.dd.enable();
+            }
+            
+            if (me.resizer) {
+                me.resizer.enable();
+            }
+
+            me.container.removeCls(Ext.baseCSSPrefix + 'window-maximized-ct');
+
+            me.syncMonitorWindowResize();
+            me.doConstrain();
+            me.fireEvent('restore', me);
+        }
+        return me;
+    },
+
+    
+    syncMonitorWindowResize: function () {
+        var me = this,
+            currentlyMonitoring = me._monitoringResize,
+            
+            yes = me.monitorResize || me.constrain || me.constrainHeader || me.maximized,
+            
+            veto = me.hidden || me.destroying || me.isDestroyed;
+
+        if (yes && !veto) {
+            
+            if (!currentlyMonitoring) {
+                
+                Ext.EventManager.onWindowResize(me.onWindowResize, me);
+                me._monitoringResize = true;
+            }
+        } else if (currentlyMonitoring) {
+            
+            Ext.EventManager.removeResizeListener(me.onWindowResize, me);
+            me._monitoringResize = false;
+        }
+    },
+
+    
+    toggleMaximize: function() {
+        return this[this.maximized ? 'restore': 'maximize']();
+    }
+
+});
+
+
+Ext.define('Ext.layout.component.field.Field', {
+
+    
+
+    extend: 'Ext.layout.component.Auto',
+
+    alias: 'layout.field',
+
+    uses: ['Ext.tip.QuickTip', 'Ext.util.TextMetrics', 'Ext.util.CSS'],
+
+    
+
+    type: 'field',
+    
+    naturalSizingProp: 'size',
+
+    beginLayout: function(ownerContext) {
+        var me = this,
+            owner = me.owner,
+            widthModel = ownerContext.widthModel,
+            ownerNaturalSize = owner[me.naturalSizingProp],
+            width;
+
+        me.callParent(arguments);
+
+        ownerContext.labelStrategy = me.getLabelStrategy();
+        ownerContext.errorStrategy = me.getErrorStrategy();
+
+        ownerContext.labelContext = ownerContext.getEl('labelEl');
+        ownerContext.bodyCellContext = ownerContext.getEl('bodyEl');
+        ownerContext.inputContext = ownerContext.getEl('inputEl');
+        ownerContext.errorContext = ownerContext.getEl('errorEl');
+
+        
+        
+        if ((Ext.isIE6 || Ext.isIE7) && Ext.isStrict && ownerContext.inputContext) {
+            me.ieInputWidthAdjustment = ownerContext.inputContext.getPaddingInfo().width + ownerContext.inputContext.getBorderInfo().width;
+        }
+
+        
+        ownerContext.labelStrategy.prepare(ownerContext, owner);
+        ownerContext.errorStrategy.prepare(ownerContext, owner);
+
+        
+        if (widthModel.shrinkWrap) {
+            
+            me.beginLayoutShrinkWrap(ownerContext);
+        } else if (widthModel.natural) {
+
+            
+            if (typeof ownerNaturalSize == 'number' && !owner.inputWidth) {
+                me.beginLayoutFixed(ownerContext, (width = ownerNaturalSize * 6.5 + 20), 'px');
+            }
+
+            
+            else {
+                me.beginLayoutShrinkWrap(ownerContext);
+            }
+            ownerContext.setWidth(width, false);
+        } else {
+            me.beginLayoutFixed(ownerContext, '100', '%');
+        }
+    },
+
+    beginLayoutFixed: function (ownerContext, width, suffix) {
+        var owner = ownerContext.target,
+            inputEl = owner.inputEl,
+            inputWidth = owner.inputWidth;
+
+        owner.el.setStyle('table-layout', 'fixed');
+        owner.bodyEl.setStyle('width', width + suffix);
+        if (inputEl && inputWidth) {
+            inputEl.setStyle('width', inputWidth + 'px');
+        }
+        ownerContext.isFixed = true;
+    },
+
+    beginLayoutShrinkWrap: function (ownerContext) {
+        var owner = ownerContext.target,
+            inputEl = owner.inputEl,
+            inputWidth = owner.inputWidth;
+
+        if (inputEl && inputEl.dom) {
+            inputEl.dom.removeAttribute('size');
+            if (inputWidth) {
+                inputEl.setStyle('width', inputWidth + 'px');
+            }
+        }
+        owner.el.setStyle('table-layout', 'auto');
+        owner.bodyEl.setStyle('width', '');
+    },
+
+    finishedLayout: function(ownerContext){
+        var owner = this.owner;
+
+        this.callParent(arguments);        
+        ownerContext.labelStrategy.finishedLayout(ownerContext, owner);
+        ownerContext.errorStrategy.finishedLayout(ownerContext, owner);
+    },
+
+    calculateOwnerHeightFromContentHeight: function(ownerContext, contentHeight) {
+        return contentHeight;
+    },
+
+    measureContentHeight: function (ownerContext) {
+        return ownerContext.el.getHeight();
+    },
+    
+    measureContentWidth: function (ownerContext) {
+        return ownerContext.el.getWidth();
+    },
+
+    measureLabelErrorHeight: function (ownerContext) {
+        return ownerContext.labelStrategy.getHeight(ownerContext) +
+               ownerContext.errorStrategy.getHeight(ownerContext);
+    },
+
+    onFocus: function() {
+        this.getErrorStrategy().onFocus(this.owner);    
+    },
+
+    
+    getLabelStrategy: function() {
+        var me = this,
+            strategies = me.labelStrategies,
+            labelAlign = me.owner.labelAlign;
+        return strategies[labelAlign] || strategies.base;
+    },
+
+    
+    getErrorStrategy: function() {
+        var me = this,
+            owner = me.owner,
+            strategies = me.errorStrategies,
+            msgTarget = owner.msgTarget;
+        return !owner.preventMark && Ext.isString(msgTarget) ?
+                (strategies[msgTarget] || strategies.elementId) :
+                strategies.none;
+    },
+
+    
+    labelStrategies: (function() {
+        var base = {
+                prepare: function(ownerContext, owner) {
+                    var cls = owner.labelCls + '-' + owner.labelAlign,
+                        labelEl = owner.labelEl;
+
+                    if (labelEl) {
+                        labelEl.addCls(cls);
+                    }
+                },
+
+                getHeight: function () {
+                    return 0;
+                },
+                
+                finishedLayout: Ext.emptyFn
+            };
+
+        return {
+            base: base,
+
+            
+            top: Ext.applyIf({        
+                        
+                getHeight: function (ownerContext) {
+                    var labelContext = ownerContext.labelContext,
+                        props = labelContext.props,
+                        height = props.height;
+                        
+                    if (height === undefined) {
+                        props.height = height = labelContext.el.getHeight();
+                    }
+
+                    return height;
+                }
+            }, base),
+
+            
+            left: base,
+
+            
+            right: base
+        };
+    }()),
+
+    
+    errorStrategies: (function() {
+        function showTip(owner) {
+            var tip = Ext.layout.component.field.Field.tip,
+                target;
+                
+            if (tip && tip.isVisible()) {
+                target = tip.activeTarget;
+                if (target && target.el === owner.getActionEl().dom) {
+                    tip.toFront(true);
+                }
+            }
+        }
+
+        var applyIf = Ext.applyIf,
+            emptyFn = Ext.emptyFn,
+            iconCls = Ext.baseCSSPrefix + 'form-invalid-icon',
+            iconWidth,
+            base = {
+                prepare: function(ownerContext, owner) {
+                    var el = owner.errorEl;
+                    if (el) {
+                        el.setDisplayed(false);
+                    }
+                },
+                getHeight: function () {
+                    return 0;
+                },
+                onFocus: emptyFn,
+                finishedLayout: emptyFn
+            };
+
+        return {
+            none: base,
+
+            
+            side: applyIf({
+                prepare: function(ownerContext, owner) {
+                    var errorEl = owner.errorEl,
+                        sideErrorCell = owner.sideErrorCell,
+                        displayError = owner.hasActiveError(),
+                        tempEl;
+
+                    
+                    if (!iconWidth) {
+                        iconWidth = (tempEl = Ext.getBody().createChild({style: 'position:absolute', cls: iconCls})).getWidth();
+                        tempEl.remove();
+                    }
+
+                    errorEl.addCls(iconCls);
+                    errorEl.set({'data-errorqtip': owner.getActiveError() || ''});
+                    if (owner.autoFitErrors) {
+                        errorEl.setDisplayed(displayError);
+                    }
+                    
+                    else {
+                        errorEl.setVisible(displayError);
+                    }
+
+                    
+                    if (sideErrorCell && owner.autoFitErrors) {
+                        sideErrorCell.setDisplayed(displayError);
+                    }
+                    owner.bodyEl.dom.colSpan = owner.getBodyColspan();
+
+                    
+                    Ext.layout.component.field.Field.initTip();
+                },
+                onFocus: showTip
+            }, base),
+
+            
+            under: applyIf({
+                prepare: function(ownerContext, owner) {
+                    var errorEl = owner.errorEl,
+                        cls = Ext.baseCSSPrefix + 'form-invalid-under';
+
+                    errorEl.addCls(cls);
+                    errorEl.setDisplayed(owner.hasActiveError());
+                },
+                getHeight: function (ownerContext) {
+                    var height = 0,
+                        errorContext, props;
+
+                    if (ownerContext.target.hasActiveError()) {
+                        errorContext = ownerContext.errorContext;
+                        props = errorContext.props;
+                        height = props.height;
+
+                        if (height === undefined) {
+                            props.height = height = errorContext.el.getHeight();
+                        }
+                    }
+
+                    return height;
+                }
+            }, base),
+
+            
+            qtip: applyIf({
+                prepare: function(ownerContext, owner) {
+                    Ext.layout.component.field.Field.initTip();
+                    owner.getActionEl().set({'data-errorqtip': owner.getActiveError() || ''});
+                },
+                onFocus: showTip
+            }, base),
+
+            
+            title: applyIf({
+                prepare: function(ownerContext, owner) {
+                    owner.el.set({'title': owner.getActiveError() || ''});
+                }
+            }, base),
+
+            
+            elementId: applyIf({
+                prepare: function(ownerContext, owner) {
+                    var targetEl = Ext.fly(owner.msgTarget);
+                    if (targetEl) {
+                        targetEl.dom.innerHTML = owner.getActiveError() || '';
+                        targetEl.setDisplayed(owner.hasActiveError());
+                    }
+                }
+            }, base)
+        };
+    }()),
+
+    statics: {
+        
+        initTip: function() {
+            var tip = this.tip;
+            if (!tip) {
+                tip = this.tip = Ext.create('Ext.tip.QuickTip', {
+                    baseCls: Ext.baseCSSPrefix + 'form-invalid-tip'
+                });
+                tip.tagConfig = Ext.apply({}, {attribute: 'errorqtip'}, tip.tagConfig);
+            }
+        },
+
+        
+        destroyTip: function() {
+            var tip = this.tip;
+            if (tip) {
+                tip.destroy();
+                delete this.tip;
+            }
+        }
+    }
+});
+
+
+Ext.define('Ext.layout.component.field.Text', {
+    extend: 'Ext.layout.component.field.Field',
+    alias: 'layout.textfield',
+    requires: ['Ext.util.TextMetrics'],
+
+    type: 'textfield',
+    
+    canGrowWidth: true,
+
+    beginLayoutCycle: function(ownerContext) {
+        var me = this;
+        
+        me.callParent(arguments);
+        
+        
+        if (ownerContext.shrinkWrap) {
+            ownerContext.inputContext.el.setStyle('height', '');
+        }
+    },
+
+    measureContentWidth: function (ownerContext) {
+        var me = this,
+            owner = me.owner,
+            width = me.callParent(arguments),
+            inputContext = ownerContext.inputContext,
+            inputEl, value, calcWidth, max, min;
+
+        if (owner.grow && me.canGrowWidth && !ownerContext.state.growHandled) {
+            inputEl = owner.inputEl;
+
+            
+            value = Ext.util.Format.htmlEncode(inputEl.dom.value || (owner.hasFocus ? '' : owner.emptyText) || '');
+            value += owner.growAppend;
+            calcWidth = inputEl.getTextWidth(value) + inputContext.getFrameInfo().width;
+
+            max = owner.growMax;
+            min = Math.min(max, width);
+            max = Math.max(owner.growMin, max, min);
+
+            
+            calcWidth = Ext.Number.constrain(calcWidth, owner.growMin, max);
+            inputContext.setWidth(calcWidth);
+            ownerContext.state.growHandled = true;
+            
+            
+            inputContext.domBlock(me, 'width');
+            width = NaN;
+        }
+        return width;
+    },
+    
+    publishInnerHeight: function(ownerContext, height) {
+        ownerContext.inputContext.setHeight(height - this.measureLabelErrorHeight(ownerContext));
+    },
+
+    beginLayoutFixed: function(ownerContext, width, suffix) {
+        var me = this,
+            ieInputWidthAdjustment = me.ieInputWidthAdjustment;
+
+        if (ieInputWidthAdjustment) {
+            
+            
+            me.owner.bodyEl.setStyle('padding-right', ieInputWidthAdjustment + 'px');
+            if(suffix === 'px') {
+                width -= ieInputWidthAdjustment;
+            }
+        }
+
+        me.callParent(arguments);
+    }
+});
+
+
+Ext.define("Ext.form.Labelable", {
+    requires: ['Ext.XTemplate'],
+
+    autoEl: {
+        tag: 'table',
+        cellpadding: 0
+    },
+
+    childEls: [
+        
+        'labelCell',
+
+        
+        'labelEl',
+
+        
+        'bodyEl',
+
+        
+        'sideErrorCell',
+
+        
+        'errorEl',
+
+        'inputRow',
+
+        'bottomPlaceHolder'
+    ],
+
+    
+    labelableRenderTpl: [
+
+        
+        '<tr id="{id}-inputRow" <tpl if="inFormLayout">id="{id}"</tpl>>',
+
+            
+            '<tpl if="labelOnLeft">',
+                '<td id="{id}-labelCell" style="{labelCellStyle}" {labelCellAttrs}>',
+                    '{beforeLabelTpl}',
+                    '<label id="{id}-labelEl" {labelAttrTpl}<tpl if="inputId"> for="{inputId}"</tpl> class="{labelCls}"',
+                        '<tpl if="labelStyle"> style="{labelStyle}"</tpl>>',
+                        '{beforeLabelTextTpl}',
+                        '<tpl if="fieldLabel">{fieldLabel}{labelSeparator}</tpl>',
+                        '{afterLabelTextTpl}',
+                    '</label>',
+                    '{afterLabelTpl}',
+                '</td>',
+            '</tpl>',
+
+            
+            '<td class="{baseBodyCls} {fieldBodyCls}" id="{id}-bodyEl" colspan="{bodyColspan}" role="presentation">',
+                '{beforeBodyEl}',
+
+                
+                '<tpl if="labelAlign==\'top\'">',
+                    '{beforeLabelTpl}',
+                    '<div id="{id}-labelCell" style="{labelCellStyle}">',
+                        '<label id="{id}-labelEl" {labelAttrTpl}<tpl if="inputId"> for="{inputId}"</tpl> class="{labelCls}"',
+                            '<tpl if="labelStyle"> style="{labelStyle}"</tpl>>',
+                            '{beforeLabelTextTpl}',
+                            '<tpl if="fieldLabel">{fieldLabel}{labelSeparator}</tpl>',
+                            '{afterLabelTextTpl}',
+                        '</label>',
+                    '</div>',
+                    '{afterLabelTpl}',
+                '</tpl>',
+
+                '{beforeSubTpl}',
+                '{[values.$comp.getSubTplMarkup()]}',
+                '{afterSubTpl}',
+
+            
+            '<tpl if="msgTarget===\'side\'">',
+                '{afterBodyEl}',
+                '</td>',
+                '<td id="{id}-sideErrorCell" vAlign="{[values.labelAlign===\'top\' && !values.hideLabel ? \'bottom\' : \'middle\']}" style="{[values.autoFitErrors ? \'display:none\' : \'\']}" width="{errorIconWidth}">',
+                    '<div id="{id}-errorEl" class="{errorMsgCls}" style="display:none;width:{errorIconWidth}px"></div>',
+                '</td>',
+            '<tpl elseif="msgTarget==\'under\'">',
+                '<div id="{id}-errorEl" class="{errorMsgClass}" colspan="2" style="display:none"></div>',
+                '{afterBodyEl}',
+                '</td>',
+            '</tpl>',
+
+        '</tr>',
+        {
+            disableFormats: true
+        }
+    ],
+
+    
+    activeErrorsTpl: [
+        '<tpl if="errors && errors.length">',
+            '<ul><tpl for="errors"><li>{.}</li></tpl></ul>',
+        '</tpl>'
+    ],
+
+    
+    isFieldLabelable: true,
+
+    
+    formItemCls: Ext.baseCSSPrefix + 'form-item',
+
+    
+    labelCls: Ext.baseCSSPrefix + 'form-item-label',
+
+    
+
+    
+    errorMsgCls: Ext.baseCSSPrefix + 'form-error-msg',
+
+    
+    baseBodyCls: Ext.baseCSSPrefix + 'form-item-body',
+
+    
+    fieldBodyCls: '',
+
+    
+    clearCls: Ext.baseCSSPrefix + 'clear',
+
+    
+    invalidCls : Ext.baseCSSPrefix + 'form-invalid',
+
+    
+    fieldLabel: undefined,
+
+    
+    labelAlign : 'left',
+
+    
+    labelWidth: 100,
+
+    
+    labelPad : 5,
+
+    
+    
+    labelSeparator : ':',
+    
+
+    
+
+    
+    hideLabel: false,
+
+    
+    hideEmptyLabel: true,
+
+    
+    preventMark: false,
+
+    
+    autoFitErrors: true,
+
+    
+    msgTarget: 'qtip',
+
+    
+
+    
+    noWrap: true,
+
+    labelableInsertions: [
+
+        
+        'beforeBodyEl',
+
+        
+        'afterBodyEl',
+
+        
+        'beforeLabelTpl',
+
+        
+        'afterLabelTpl',
+
+        
+        'beforeSubTpl',
+
+        
+        'afterSubTpl',
+
+        
+        'beforeLabelTextTpl',
+
+        
+        'afterLabelTextTpl',
+
+        
+        'labelAttrTpl'
+    ],
+
+    
+    labelableRenderProps: [ 'allowBlank', 'id', 'labelAlign', 'fieldBodyCls', 'baseBodyCls',
+                            'clearCls', 'labelSeparator', 'msgTarget' ],
+
+    
+    initLabelable: function() {
+        var me = this,
+            padding = me.padding;
+
+        
+        
+        
+        if (padding) {
+            me.padding = undefined;
+            me.extraMargins = Ext.Element.parseBox(padding);
+        }
+
+        me.addCls(me.formItemCls);
+        
+        
+        me.lastActiveError = '';
+
+        me.addEvents(
+            
+            'errorchange'
+        );
+    },
+
+    
+    trimLabelSeparator: function() {
+        var me = this,
+            separator = me.labelSeparator,
+            label = me.fieldLabel || '',
+            lastChar = label.substr(label.length - 1);
+
+        
+        return lastChar === separator ? label.slice(0, -1) : label;
+    },
+
+    
+    getFieldLabel: function() {
+        return this.trimLabelSeparator();
+    },
+    
+    
+    setFieldLabel: function(label){
+        label = label || '';
+        
+        var me = this,
+            separator = me.labelSeparator,
+            labelEl = me.labelEl;
+        
+        me.fieldLabel = label;
+        if (me.rendered) {
+            if (Ext.isEmpty(label) && me.hideEmptyLabel) {
+                labelEl.parent().setDisplayed('none');
+            } else {
+                if (separator) {
+                    label = me.trimLabelSeparator() + separator;
+                }
+                labelEl.update(label);
+                labelEl.parent().setDisplayed('');
+            }
+            me.updateLayout();
+        }
+    },
+
+    getInsertionRenderData: function (data, names) {
+        var i = names.length,
+            name, value;
+
+        while (i--) {
+            name = names[i];
+            value = this[name];
+
+            if (value) {
+                if (typeof value != 'string') {
+                    if (!value.isTemplate) {
+                        value = Ext.XTemplate.getTpl(this, name);
+                    }
+                    value = value.apply(data);
+                }
+            }
+
+            data[name] = value || '';
+        }
+
+        return data;
+    },
+
+    
+    getLabelableRenderData: function() {
+        var me = this,
+            data,
+            tempEl,
+            topLabel = me.labelAlign === 'top';
+
+        if (!Ext.form.Labelable.errorIconWidth) {
+            Ext.form.Labelable.errorIconWidth = (tempEl = Ext.resetElement.createChild({style: 'position:absolute', cls: Ext.baseCSSPrefix + 'form-invalid-icon'})).getWidth();
+            tempEl.remove();
+        }
+
+        data = Ext.copyTo({
+            inFormLayout   : me.ownerLayout && me.ownerLayout.type === 'form',
+            inputId        : me.getInputId(),
+            labelOnLeft    : !topLabel,
+            hideLabel      : !me.hasVisibleLabel(),
+            fieldLabel     : me.getFieldLabel(),
+            labelCellStyle : me.getLabelCellStyle(),
+            labelCellAttrs : me.getLabelCellAttrs(),
+            labelCls       : me.getLabelCls(),
+            labelStyle     : me.getLabelStyle(),
+            bodyColspan    : me.getBodyColspan(),
+            externalError  : !me.autoFitErrors,
+            errorMsgCls    : me.getErrorMsgCls(),
+            errorIconWidth : Ext.form.Labelable.errorIconWidth
+        },
+        me, me.labelableRenderProps, true);
+
+        me.getInsertionRenderData(data, me.labelableInsertions);
+
+        return data;
+    },
+    
+    beforeLabelableRender: function() {
+        var me = this;
+        if (me.ownerLayout) {
+            me.addCls(Ext.baseCSSPrefix + me.ownerLayout.type + '-form-item');
+        }
+    },
+
+    onLabelableRender: function() {
+        var me = this,
+            margins,
+            side,
+            style = {};
+
+        if (me.extraMargins) {
+            margins = me.el.getMargin();
+            for (side in margins) {
+                if (margins.hasOwnProperty(side)) {
+                    style['margin-' + side] = (margins[side] + me.extraMargins[side]) + 'px';
+                }
+            }
+            me.el.setStyle(style);
+        }
+    },
+    
+    
+    hasVisibleLabel: function(){
+        if (this.hideLabel) {
+            return false;
+        }
+        return !(this.hideEmptyLabel && !this.getFieldLabel());
+    },
+    
+    
+    getBodyColspan: function() {
+        var me = this,
+            result;
+
+        if (me.msgTarget === 'side' && (!me.autoFitErrors || me.hasActiveError())) {
+            result = 1;
+        } else {
+            result = 2;
+        }
+        if (me.labelAlign !== 'top' && !me.hasVisibleLabel()) {
+            result++;
+        }
+        return result;
+    },
+    
+    getLabelCls: function() {
+        var labelCls = this.labelCls,
+            labelClsExtra = this.labelClsExtra;
+
+        if (this.labelAlign === 'top') {
+            labelCls += '-top';
+        }
+        return labelClsExtra ? labelCls + ' ' + labelClsExtra : labelCls;
+    },
+
+    getLabelCellStyle: function() {
+        var me = this,
+            hideLabelCell = me.hideLabel || (!me.fieldLabel && me.hideEmptyLabel);
+
+        return hideLabelCell ? 'display:none;' : '';
+    },
+    
+    getErrorMsgCls: function() {
+        var me = this,
+            hideLabelCell = (me.hideLabel || (!me.fieldLabel && me.hideEmptyLabel));
+        
+        return me.errorMsgCls + (!hideLabelCell && me.labelAlign === 'top' ? ' ' + Ext.baseCSSPrefix + 'lbl-top-err-icon' : '');
+    },
+
+    getLabelCellAttrs: function() {
+        var me = this,
+            labelAlign = me.labelAlign,
+            result = '';
+
+        if (labelAlign !== 'top') {
+            result = 'valign="top" halign="' + labelAlign + '" width="' + (me.labelWidth + me.labelPad) + '"';
+        }
+        return result + ' class="' + Ext.baseCSSPrefix + 'field-label-cell"';
+    },
+    
+    
+    getLabelStyle: function(){
+        var me = this,
+            labelPad = me.labelPad,
+            labelStyle = '';
+
+        
+        
+        if (me.labelAlign !== 'top') {
+            if (me.labelWidth) {
+                labelStyle = 'width:' + me.labelWidth + 'px;';
+            }
+            labelStyle += 'margin-right:' + labelPad + 'px;';
+        }
+        
+        return labelStyle + (me.labelStyle || '');
+    },
+
+    
+    getSubTplMarkup: function() {
+        return '';
+    },
+
+    
+    getInputId: function() {
+        return '';
+    },
+
+    
+    getActiveError : function() {
+        return this.activeError || '';
+    },
+
+    
+    hasActiveError: function() {
+        return !!this.getActiveError();
+    },
+
+    
+    setActiveError: function(msg) {
+        this.setActiveErrors(msg);
+    },
+
+    
+    getActiveErrors: function() {
+        return this.activeErrors || [];
+    },
+
+    
+    setActiveErrors: function(errors) {
+        errors = Ext.Array.from(errors);
+        this.activeError = errors[0];
+        this.activeErrors = errors;
+        this.activeError = this.getTpl('activeErrorsTpl').apply({errors: errors});
+        this.renderActiveError();
+    },
+
+    
+    unsetActiveError: function() {
+        delete this.activeError;
+        delete this.activeErrors;
+        this.renderActiveError();
+    },
+
+    
+    renderActiveError: function() {
+        var me = this,
+            activeError = me.getActiveError(),
+            hasError = !!activeError;
+
+        if (activeError !== me.lastActiveError) {
+            me.fireEvent('errorchange', me, activeError);
+            me.lastActiveError = activeError;
+        }
+
+        if (me.rendered && !me.isDestroyed && !me.preventMark) {
+            
+            me.el[hasError ? 'addCls' : 'removeCls'](me.invalidCls);
+
+            
+            me.getActionEl().dom.setAttribute('aria-invalid', hasError);
+
+            
+            if (me.errorEl) {
+                me.errorEl.dom.innerHTML = activeError;
+            }
+        }
+    },
+
+    
+    setFieldDefaults: function(defaults) {
+        var me = this,
+            val, key;
+
+        for (key in defaults) {
+            if (defaults.hasOwnProperty(key)) {
+                val = defaults[key];
+
+                if (!me.hasOwnProperty(key)) {
+                    me[key] = val;
+                }
+            }
+        }
+    }
+});
+
+
+Ext.define('Ext.form.field.Field', {
+    
+    isFormField : true,
+
+    
+
+    
+
+    
+    disabled : false,
+
+    
+    submitValue: true,
+
+    
+    validateOnChange: true,
+
+    
+    suspendCheckChange: 0,
+
+    
+    initField: function() {
+        this.addEvents(
+            
+            'change',
+            
+            'validitychange',
+            
+            'dirtychange'
+        );
+
+        this.initValue();
+    },
+
+    
+    initValue: function() {
+        var me = this;
+
+        me.value = me.transformOriginalValue(me.value);
+        
+        me.originalValue = me.lastValue = me.value;
+
+        
+        me.suspendCheckChange++;
+        me.setValue(me.value);
+        me.suspendCheckChange--;
+    },
+    
+    
+    transformOriginalValue: function(value){
+        return value;
+    },
+
+    
+    getName: function() {
+        return this.name;
+    },
+
+    
+    getValue: function() {
+        return this.value;
+    },
+
+    
+    setValue: function(value) {
+        var me = this;
+        me.value = value;
+        me.checkChange();
+        return me;
+    },
+
+    
+    isEqual: function(value1, value2) {
+        return String(value1) === String(value2);
+    },
+
+    
+    isEqualAsString: function(value1, value2){
+        return String(Ext.value(value1, '')) === String(Ext.value(value2, ''));
+    },
+
+    
+    getSubmitData: function() {
+        var me = this,
+            data = null;
+        if (!me.disabled && me.submitValue && !me.isFileUpload()) {
+            data = {};
+            data[me.getName()] = '' + me.getValue();
+        }
+        return data;
+    },
+
+    
+    getModelData: function() {
+        var me = this,
+            data = null;
+        if (!me.disabled && !me.isFileUpload()) {
+            data = {};
+            data[me.getName()] = me.getValue();
+        }
+        return data;
+    },
+
+    
+    reset : function(){
+        var me = this;
+
+        me.beforeReset();
+        me.setValue(me.originalValue);
+        me.clearInvalid();
+        
+        delete me.wasValid;
+    },
+    
+    
+    beforeReset: Ext.emptyFn,
+
+    
+    resetOriginalValue: function() {
+        this.originalValue = this.getValue();
+        this.checkDirty();
+    },
+
+    
+    checkChange: function() {
+        if (!this.suspendCheckChange) {
+            var me = this,
+                newVal = me.getValue(),
+                oldVal = me.lastValue;
+            if (!me.isEqual(newVal, oldVal) && !me.isDestroyed) {
+                me.lastValue = newVal;
+                me.fireEvent('change', me, newVal, oldVal);
+                me.onChange(newVal, oldVal);
+            }
+        }
+    },
+
+    
+    onChange: function(newVal, oldVal) {
+        if (this.validateOnChange) {
+            this.validate();
+        }
+        this.checkDirty();
+    },
+
+    
+    isDirty : function() {
+        var me = this;
+        return !me.disabled && !me.isEqual(me.getValue(), me.originalValue);
+    },
+
+    
+    checkDirty: function() {
+        var me = this,
+            isDirty = me.isDirty();
+        if (isDirty !== me.wasDirty) {
+            me.fireEvent('dirtychange', me, isDirty);
+            me.onDirtyChange(isDirty);
+            me.wasDirty = isDirty;
+        }
+    },
+
+    
+    onDirtyChange: Ext.emptyFn,
+
+    
+    getErrors: function(value) {
+        return [];
+    },
+
+    
+    isValid : function() {
+        var me = this;
+        return me.disabled || Ext.isEmpty(me.getErrors());
+    },
+
+    
+    validate : function() {
+        var me = this,
+            isValid = me.isValid();
+        if (isValid !== me.wasValid) {
+            me.wasValid = isValid;
+            me.fireEvent('validitychange', me, isValid);
+        }
+        return isValid;
+    },
+
+    
+    batchChanges: function(fn) {
+        try {
+            this.suspendCheckChange++;
+            fn();
+        } catch(e){
+            throw e;
+        } finally {
+            this.suspendCheckChange--;
+        }
+        this.checkChange();
+    },
+
+    
+    isFileUpload: function() {
+        return false;
+    },
+
+    
+    extractFileInput: function() {
+        return null;
+    },
+
+    
+    markInvalid: Ext.emptyFn,
+
+    
+    clearInvalid: Ext.emptyFn
+
+});
+
+
+Ext.define('Ext.form.field.Base', {
+    extend: 'Ext.Component',
+    mixins: {
+        labelable: 'Ext.form.Labelable',
+        field: 'Ext.form.field.Field'
+    },
+    alias: 'widget.field',
+    alternateClassName: ['Ext.form.Field', 'Ext.form.BaseField'],
+    requires: ['Ext.util.DelayedTask', 'Ext.XTemplate', 'Ext.layout.component.field.Field'],
+
+    
+    fieldSubTpl: [ 
+        '<input id="{id}" type="{type}" {inputAttrTpl}',
+            ' size="1"', 
+            '<tpl if="name"> name="{name}"</tpl>',
+            '<tpl if="value"> value="{[Ext.util.Format.htmlEncode(values.value)]}"</tpl>',
+            '<tpl if="placeholder"> placeholder="{placeholder}"</tpl>',
+            '{%if (values.maxLength !== undefined){%} maxlength="{maxLength}"{%}%}',
+            '<tpl if="readOnly"> readonly="readonly"</tpl>',
+            '<tpl if="disabled"> disabled="disabled"</tpl>',
+            '<tpl if="tabIdx"> tabIndex="{tabIdx}"</tpl>',
+            '<tpl if="fieldStyle"> style="{fieldStyle}"</tpl>',
+        ' class="{fieldCls} {typeCls} {editableCls}" autocomplete="off"/>',
+        {
+            disableFormats: true
+        }
+    ],
+
+    subTplInsertions: [
+        
+        'inputAttrTpl'
+    ],
+
+    
+
+    
+    inputType: 'text',
+
+    
+
+    
+    
+    invalidText : 'The value in this field is invalid',
+    
+
+    
+    fieldCls : Ext.baseCSSPrefix + 'form-field',
+
+    
+
+    
+    focusCls : 'form-focus',
+
+    
+    dirtyCls : Ext.baseCSSPrefix + 'form-dirty',
+
+    
+    checkChangeEvents: Ext.isIE && (!document.documentMode || document.documentMode < 9) ?
+                        ['change', 'propertychange'] :
+                        ['change', 'input', 'textInput', 'keyup', 'dragdrop'],
+
+    
+    checkChangeBuffer: 50,
+
+    componentLayout: 'field',
+
+    
+    readOnly : false,
+
+    
+    readOnlyCls: Ext.baseCSSPrefix + 'form-readonly',
+
+    
+
+    
+    validateOnBlur: true,
+
+    
+    hasFocus : false,
+
+    baseCls: Ext.baseCSSPrefix + 'field',
+
+    maskOnDisable: false,
+
+    
+    initComponent : function() {
+        var me = this;
+
+        me.callParent();
+
+        me.subTplData = me.subTplData || {};
+
+        me.addEvents(
+            
+            'specialkey',
+
+            
+            'writeablechange'
+        );
+
+        
+        me.initLabelable();
+        me.initField();
+
+        
+        if (!me.name) {
+            me.name = me.getInputId();
+        }
+    },
+    
+    beforeRender: function(){
+        var me = this;
+            
+        me.callParent(arguments);
+        me.beforeLabelableRender(arguments);
+        if (me.readOnly) {
+            me.addCls(me.readOnlyCls);
+        }
+    },
+
+    
+    getInputId: function() {
+        return this.inputId || (this.inputId = this.id + '-inputEl');
+    },
+
+    
+    getSubTplData: function() {
+        var me = this,
+            type = me.inputType,
+            inputId = me.getInputId(),
+            data;
+        
+        data = Ext.apply({
+            id         : inputId,
+            cmpId      : me.id,
+            name       : me.name || inputId,
+            disabled   : me.disabled,
+            readOnly   : me.readOnly,
+            value      : me.getRawValue(),
+            type       : type,
+            fieldCls   : me.fieldCls,
+            fieldStyle : me.getFieldStyle(),
+            tabIdx     : me.tabIndex,
+            typeCls    : Ext.baseCSSPrefix + 'form-' + (type === 'password' ? 'text' : type)
+        }, me.subTplData);
+
+        me.getInsertionRenderData(data, me.subTplInsertions);
+
+        return data;
+    },
+
+    afterFirstLayout: function() {
+        this.callParent();
+        var el = this.inputEl;
+        if (el) {
+            el.selectable();
+        }
+    },
+
+    applyRenderSelectors: function() {
+        var me = this;
+
+        me.callParent();
+
+        
+        me.inputEl = me.el.getById(me.getInputId());
+    },
+
+    
+    getSubTplMarkup: function() {
+        return this.getTpl('fieldSubTpl').apply(this.getSubTplData());
+    },
+
+    initRenderTpl: function() {
+        var me = this;
+        if (!me.hasOwnProperty('renderTpl')) {
+            me.renderTpl = me.getTpl('labelableRenderTpl');
+        }
+        return me.callParent();
+    },
+
+    initRenderData: function() {
+        return Ext.applyIf(this.callParent(), this.getLabelableRenderData());
+    },
+
+    
+    setFieldStyle: function(style) {
+        var me = this,
+            inputEl = me.inputEl;
+        if (inputEl) {
+            inputEl.applyStyles(style);
+        }
+        me.fieldStyle = style;
+    },
+
+    getFieldStyle: function() {
+        return 'width:100%;' + (Ext.isObject(this.fieldStyle) ? Ext.DomHelper.generateStyles(this.fieldStyle) : this.fieldStyle ||'');
+    },
+
+    
+    onRender : function() {
+        var me = this;
+        me.callParent(arguments);
+        me.onLabelableRender();
+        me.renderActiveError();
+    },
+
+    getFocusEl: function() {
+        return this.inputEl;
+    },
+
+    isFileUpload: function() {
+        return this.inputType === 'file';
+    },
+
+    extractFileInput: function() {
+        var me = this,
+            fileInput = me.isFileUpload() ? me.inputEl.dom : null,
+            clone;
+        if (fileInput) {
+            clone = fileInput.cloneNode(true);
+            fileInput.parentNode.replaceChild(clone, fileInput);
+            me.inputEl = Ext.get(clone);
+        }
+        return fileInput;
+    },
+
+    
+    getSubmitData: function() {
+        var me = this,
+            data = null,
+            val;
+        if (!me.disabled && me.submitValue && !me.isFileUpload()) {
+            val = me.getSubmitValue();
+            if (val !== null) {
+                data = {};
+                data[me.getName()] = val;
+            }
+        }
+        return data;
+    },
+
+    
+    getSubmitValue: function() {
+        return this.processRawValue(this.getRawValue());
+    },
+
+    
+    getRawValue: function() {
+        var me = this,
+            v = (me.inputEl ? me.inputEl.getValue() : Ext.value(me.rawValue, ''));
+        me.rawValue = v;
+        return v;
+    },
+
+    
+    setRawValue: function(value) {
+        var me = this;
+        value = Ext.value(me.transformRawValue(value), '');
+        me.rawValue = value;
+
+        
+        if (me.inputEl) {
+            me.inputEl.dom.value = value;
+        }
+        return value;
+    },
+    
+    
+    transformRawValue: function(value) {
+        return value;
+    },
+
+    
+    valueToRaw: function(value) {
+        return '' + Ext.value(value, '');
+    },
+
+    
+    rawToValue: function(rawValue) {
+        return rawValue;
+    },
+
+    
+    processRawValue: function(value) {
+        return value;
+    },
+
+    
+    getValue: function() {
+        var me = this,
+            val = me.rawToValue(me.processRawValue(me.getRawValue()));
+        me.value = val;
+        return val;
+    },
+
+    
+    setValue: function(value) {
+        var me = this;
+        me.setRawValue(me.valueToRaw(value));
+        return me.mixins.field.setValue.call(me, value);
+    },
+
+    onBoxReady: function() {
+        var me = this;
+        me.callParent();
+        
+        if (me.setReadOnlyOnBoxReady) {
+            me.setReadOnly(me.readOnly);
+        }
+            
+    },
+
+    
+    onDisable: function() {
+        var me = this,
+            inputEl = me.inputEl;
+            
+        me.callParent();
+        if (inputEl) {
+            inputEl.dom.disabled = true;
+            if (me.hasActiveError()) {
+                
+                me.clearInvalid();
+                me.needsValidateOnEnable = true;
+            }
+        }
+    },
+
+    
+    onEnable: function() {
+        var me = this,
+            inputEl = me.inputEl;
+            
+        me.callParent();
+        if (inputEl) {
+            inputEl.dom.disabled = false;
+            if (me.needsValidateOnEnable) {
+                delete me.needsValidateOnEnable;
+                
+                me.forceValidation = true;
+                me.isValid();
+                delete me.forceValidation;
+            }
+        }
+    },
+
+    
+    setReadOnly: function(readOnly) {
+        var me = this,
+            inputEl = me.inputEl;
+        readOnly = !!readOnly;
+        me[readOnly ? 'addCls' : 'removeCls'](me.readOnlyCls);
+        me.readOnly = readOnly;
+        if (inputEl) {
+            inputEl.dom.readOnly = readOnly;
+        } else if (me.rendering) {
+            me.setReadOnlyOnBoxReady = true;
+        }
+        me.fireEvent('writeablechange', me, readOnly);
+    },
+
+    
+    fireKey: function(e){
+        if(e.isSpecialKey()){
+            this.fireEvent('specialkey', this, new Ext.EventObjectImpl(e));
+        }
+    },
+
+    
+    initEvents : function(){
+        var me = this,
+            inputEl = me.inputEl,
+            onChangeTask,
+            onChangeEvent,
+            events = me.checkChangeEvents,
+            e,
+            eLen   = events.length,
+            event;
+
+        
+        
+        if (me.inEditor) {
+            me.onBlur = Ext.Function.createBuffered(me.onBlur, 10);
+        }
+        if (inputEl) {
+            me.mon(inputEl, Ext.EventManager.getKeyEvent(), me.fireKey,  me);
+
+            
+            onChangeTask = new Ext.util.DelayedTask(me.checkChange, me);
+            me.onChangeEvent = onChangeEvent = function() {
+                onChangeTask.delay(me.checkChangeBuffer);
+            };
+
+            for (e = 0; e < eLen; e++) {
+                event = events[e];
+
+                if (event === 'propertychange') {
+                    me.usesPropertychange = true;
+                }
+
+                me.mon(inputEl, event, onChangeEvent);
+            }
+        }
+        me.callParent();
+    },
+
+    doComponentLayout: function() {
+        var me = this,
+            inputEl = me.inputEl,
+            usesPropertychange = me.usesPropertychange,
+            ename = 'propertychange',
+            onChangeEvent = me.onChangeEvent;
+
+        
+        
+        
+        if (usesPropertychange) {
+            me.mun(inputEl, ename, onChangeEvent);
+        }
+        me.callParent(arguments);
+        if (usesPropertychange) {
+            me.mon(inputEl, ename, onChangeEvent);
+        }
+    },
+
+    
+    onDirtyChange: function(isDirty) {
+        this[isDirty ? 'addCls' : 'removeCls'](this.dirtyCls);
+    },
+
+
+    
+    isValid : function() {
+        var me = this,
+            disabled = me.disabled,
+            validate = me.forceValidation || !disabled;
+            
+        
+        return validate ? me.validateValue(me.processRawValue(me.getRawValue())) : disabled;
+    },
+
+
+    
+    validateValue: function(value) {
+        var me = this,
+            errors = me.getErrors(value),
+            isValid = Ext.isEmpty(errors);
+        if (!me.preventMark) {
+            if (isValid) {
+                me.clearInvalid();
+            } else {
+                me.markInvalid(errors);
+            }
+        }
+
+        return isValid;
+    },
+
+    
+    markInvalid : function(errors) {
+        
+        var me = this,
+            oldMsg = me.getActiveError();
+        me.setActiveErrors(Ext.Array.from(errors));
+        if (oldMsg !== me.getActiveError()) {
+            me.updateLayout();
+        }
+    },
+
+    
+    clearInvalid : function() {
+        
+        var me = this,
+            hadError = me.hasActiveError();
+        me.unsetActiveError();
+        if (hadError) {
+            me.updateLayout();
+        }
+    },
+
+    
+    renderActiveError: function() {
+        var me = this,
+            hasError = me.hasActiveError();
+        if (me.inputEl) {
+            
+            me.inputEl[hasError ? 'addCls' : 'removeCls'](me.invalidCls + '-field');
+        }
+        me.mixins.labelable.renderActiveError.call(me);
+    },
+
+
+    getActionEl: function() {
+        return this.inputEl || this.el;
+    }
+
+});
+
+
+Ext.define('Ext.form.field.VTypes', (function(){
+    
+    var alpha = /^[a-zA-Z_]+$/,
+        alphanum = /^[a-zA-Z0-9_]+$/,
+        email = /^(\w+)([\-+.][\w]+)*@(\w[\-\w]*\.){1,5}([A-Za-z]){2,6}$/,
+        url = /(((^https?)|(^ftp)):\/\/([\-\w]+\.)+\w{2,3}(\/[%\-\w]+(\.\w{2,})?)*(([\w\-\.\?\\\/+@&#;`~=%!]*)(\.\w{2,})?)*\/?)/i;
+
+    
+    return {
+        singleton: true,
+        alternateClassName: 'Ext.form.VTypes',
+
+        
+        'email' : function(v){
+            return email.test(v);
+        },
+        
+        
+        'emailText' : 'This field should be an e-mail address in the format "user@example.com"',
+        
+        
+        'emailMask' : /[a-z0-9_\.\-@\+]/i,
+
+        
+        'url' : function(v){
+            return url.test(v);
+        },
+        
+        
+        'urlText' : 'This field should be a URL in the format "http:/'+'/www.example.com"',
+        
+
+        
+        'alpha' : function(v){
+            return alpha.test(v);
+        },
+        
+        
+        'alphaText' : 'This field should only contain letters and _',
+        
+        
+        'alphaMask' : /[a-z_]/i,
+
+        
+        'alphanum' : function(v){
+            return alphanum.test(v);
+        },
+        
+        
+        'alphanumText' : 'This field should only contain letters, numbers and _',
+        
+        
+        'alphanumMask' : /[a-z0-9_]/i
+    };
+}()));
+
+
+Ext.define('Ext.form.field.Text', {
+    extend:'Ext.form.field.Base',
+    alias: 'widget.textfield',
+    requires: ['Ext.form.field.VTypes', 'Ext.layout.component.field.Text'],
+    alternateClassName: ['Ext.form.TextField', 'Ext.form.Text'],
+
+    
+
+    
+
+    
+    size: 20,
+
+    
+
+    
+    growMin : 30,
+
+    
+    growMax : 800,
+
+    
+    
+    growAppend: 'W',
+    
+
+    
+
+    
+
+    
+
+    
+    allowBlank : true,
+
+    
+    minLength : 0,
+
+    
+    maxLength : Number.MAX_VALUE,
+
+    
+
+    
+    
+    minLengthText : 'The minimum length for this field is {0}',
+    
+
+    
+    
+    maxLengthText : 'The maximum length for this field is {0}',
+    
+
+    
+
+    
+    
+    blankText : 'This field is required',
+    
+
+    
+
+    
+
+    
+    regexText : '',
+
+    
+
+    
+    emptyCls : Ext.baseCSSPrefix + 'form-empty-field',
+
+    
+    requiredCls : Ext.baseCSSPrefix + 'form-required-field',
+
+    
+
+    componentLayout: 'textfield',
+
+    
+    valueContainsPlaceholder : false,
+
+
+    initComponent: function () {
+        var me = this;
+
+        me.callParent();
+
+        me.addEvents(
+            
+            'autosize',
+
+            
+            'keydown',
+            
+            'keyup',
+            
+            'keypress'
+        );
+        me.addStateEvents('change');
+        me.setGrowSizePolicy();
+    },
+
+    
+    setGrowSizePolicy: function(){
+        if (this.grow) {
+            this.shrinkWrap |= 1; 
+        }    
+    },
+
+    
+    initEvents : function(){
+        var me = this,
+            el = me.inputEl;
+
+        me.callParent();
+        if(me.selectOnFocus || me.emptyText){
+            me.mon(el, 'mousedown', me.onMouseDown, me);
+        }
+        if(me.maskRe || (me.vtype && me.disableKeyFilter !== true && (me.maskRe = Ext.form.field.VTypes[me.vtype+'Mask']))){
+            me.mon(el, 'keypress', me.filterKeys, me);
+        }
+
+        if (me.enableKeyEvents) {
+            me.mon(el, {
+                scope: me,
+                keyup: me.onKeyUp,
+                keydown: me.onKeyDown,
+                keypress: me.onKeyPress
+            });
+        }
+    },
+
+    
+    isEqual: function(value1, value2) {
+        return this.isEqualAsString(value1, value2);
+    },
+
+    
+    onChange: function() {
+        this.callParent();
+        this.autoSize();
+    },
+
+    getSubTplData: function() {
+        var me = this,
+            value = me.getRawValue(),
+            isEmpty = me.emptyText && value.length < 1,
+            maxLength = me.maxLength,
+            placeholder;
+            
+        
+        
+        
+        if (me.enforceMaxLength) {
+            if (maxLength === Number.MAX_VALUE) {
+                maxLength = undefined;
+            }
+        } else {
+            maxLength = undefined;
+        }
+
+        if (isEmpty) {
+            if (Ext.supports.Placeholder) {
+                placeholder = me.emptyText;
+            } else {
+                value = me.emptyText;
+                me.valueContainsPlaceholder = true;
+            }
+        }
+
+        return Ext.apply(me.callParent(), {
+            maxLength   : maxLength,
+            readOnly    : me.readOnly,
+            placeholder : placeholder,
+            value       : value,
+            fieldCls    : me.fieldCls + ((isEmpty && (placeholder || value)) ? ' ' + me.emptyCls : '') + (me.allowBlank ? '' :  ' ' + me.requiredCls)
+        });
+    },
+
+    afterRender: function(){
+        this.autoSize();
+        this.callParent();
+    },
+
+    onMouseDown: function(e){
+        var me = this;
+        if(!me.hasFocus){
+            me.mon(me.inputEl, 'mouseup', Ext.emptyFn, me, { single: true, preventDefault: true });
+        }
+    },
+
+    
+    processRawValue: function(value) {
+        var me = this,
+            stripRe = me.stripCharsRe,
+            newValue;
+
+        if (stripRe) {
+            newValue = value.replace(stripRe, '');
+            if (newValue !== value) {
+                me.setRawValue(newValue);
+                value = newValue;
+            }
+        }
+        return value;
+    },
+
+    
+    onDisable: function(){
+        this.callParent();
+        if (Ext.isIE) {
+            this.inputEl.dom.unselectable = 'on';
+        }
+    },
+
+    
+    onEnable: function(){
+        this.callParent();
+        if (Ext.isIE) {
+            this.inputEl.dom.unselectable = '';
+        }
+    },
+
+    onKeyDown: function(e) {
+        this.fireEvent('keydown', this, e);
+    },
+
+    onKeyUp: function(e) {
+        this.fireEvent('keyup', this, e);
+    },
+
+    onKeyPress: function(e) {
+        this.fireEvent('keypress', this, e);
+    },
+
+    
+    reset : function(){
+        this.callParent();
+        this.applyEmptyText();
+    },
+
+    applyEmptyText : function(){
+        var me = this,
+            emptyText = me.emptyText,
+            isEmpty;
+
+        if (me.rendered && emptyText) {
+            isEmpty = me.getRawValue().length < 1 && !me.hasFocus;
+
+            if (Ext.supports.Placeholder) {
+                me.inputEl.dom.placeholder = emptyText;
+            } else if (isEmpty) {
+                me.setRawValue(emptyText);
+                me.valueContainsPlaceholder = true;
+            }
+
+            
+            
+            if (isEmpty) {
+                me.inputEl.addCls(me.emptyCls);
+            }
+
+            me.autoSize();
+        }
+    },
+    
+    afterFirstLayout: function() {
+        this.callParent();
+        if (Ext.isIE && this.disabled) {
+            var el = this.inputEl;
+            if (el) {
+                el.dom.unselectable = 'on';
+            }
+        }
+    },
+    
+    
+    preFocus : function(){
+        var me = this,
+            inputEl = me.inputEl,
+            emptyText = me.emptyText,
+            isEmpty;
+
+        me.callParent(arguments);
+        if ((emptyText && !Ext.supports.Placeholder) && (inputEl.dom.value === me.emptyText && me.valueContainsPlaceholder)) {
+            me.setRawValue('');
+            isEmpty = true;
+            inputEl.removeCls(me.emptyCls);
+            me.valueContainsPlaceholder = false;
+        } else if (Ext.supports.Placeholder) {
+            me.inputEl.removeCls(me.emptyCls);
+        }
+        if (me.selectOnFocus || isEmpty) {
+            inputEl.dom.select();
+        }
+    },
+
+    onFocus: function() {
+        var me = this;
+        me.callParent(arguments);
+        if (me.emptyText) {
+            me.autoSize();
+        }
+    },
+
+    
+    postBlur : function(){
+        this.callParent(arguments);
+        this.applyEmptyText();
+    },
+
+    
+    filterKeys : function(e){
+        
+        if (e.ctrlKey && !e.altKey) {
+            return;
+        }
+        var key = e.getKey(),
+            charCode = String.fromCharCode(e.getCharCode());
+
+        if((Ext.isGecko || Ext.isOpera) && (e.isNavKeyPress() || key === e.BACKSPACE || (key === e.DELETE && e.button === -1))){
+            return;
+        }
+
+        if((!Ext.isGecko && !Ext.isOpera) && e.isSpecialKey() && !charCode){
+            return;
+        }
+        if(!this.maskRe.test(charCode)){
+            e.stopEvent();
+        }
+    },
+
+    getState: function() {
+        return this.addPropertyToState(this.callParent(), 'value');
+    },
+
+    applyState: function(state) {
+        this.callParent(arguments);
+        if(state.hasOwnProperty('value')) {
+            this.setValue(state.value);
+        }
+    },
+
+    
+    getRawValue: function() {
+        var me = this,
+            v = me.callParent();
+        if (v === me.emptyText && me.valueContainsPlaceholder) {
+            v = '';
+        }
+        return v;
+    },
+
+    
+    setValue: function(value) {
+        var me = this,
+            inputEl = me.inputEl;
+
+        if (inputEl && me.emptyText && !Ext.isEmpty(value)) {
+            inputEl.removeCls(me.emptyCls);
+            me.valueContainsPlaceholder = false;
+        }
+
+        me.callParent(arguments);
+
+        me.applyEmptyText();
+        return me;
+    },
+
+    
+    getErrors: function(value) {
+        var me = this,
+            errors = me.callParent(arguments),
+            validator = me.validator,
+            emptyText = me.emptyText,
+            allowBlank = me.allowBlank,
+            vtype = me.vtype,
+            vtypes = Ext.form.field.VTypes,
+            regex = me.regex,
+            format = Ext.String.format,
+            msg;
+
+        value = value || me.processRawValue(me.getRawValue());
+
+        if (Ext.isFunction(validator)) {
+            msg = validator.call(me, value);
+            if (msg !== true) {
+                errors.push(msg);
+            }
+        }
+
+        if (value.length < 1 || (value === me.emptyText && me.valueContainsPlaceholder)) {
+            if (!allowBlank) {
+                errors.push(me.blankText);
+            }
+            
+            return errors;
+        }
+
+        if (value.length < me.minLength) {
+            errors.push(format(me.minLengthText, me.minLength));
+        }
+
+        if (value.length > me.maxLength) {
+            errors.push(format(me.maxLengthText, me.maxLength));
+        }
+
+        if (vtype) {
+            if(!vtypes[vtype](value, me)){
+                errors.push(me.vtypeText || vtypes[vtype +'Text']);
+            }
+        }
+
+        if (regex && !regex.test(value)) {
+            errors.push(me.regexText || me.invalidText);
+        }
+
+        return errors;
+    },
+
+    
+    selectText : function(start, end){
+        var me = this,
+            v = me.getRawValue(),
+            doFocus = true,
+            el = me.inputEl.dom,
+            undef,
+            range;
+
+        if (v.length > 0) {
+            start = start === undef ? 0 : start;
+            end = end === undef ? v.length : end;
+            if (el.setSelectionRange) {
+                el.setSelectionRange(start, end);
+            }
+            else if(el.createTextRange) {
+                range = el.createTextRange();
+                range.moveStart('character', start);
+                range.moveEnd('character', end - v.length);
+                range.select();
+            }
+            doFocus = Ext.isGecko || Ext.isOpera;
+        }
+        if (doFocus) {
+            me.focus();
+        }
+    },
+
+    
+    autoSize: function() {
+        var me = this;
+        if (me.grow && me.rendered) {
+            me.autoSizing = true;
+            me.updateLayout();
+        }
+    },
+
+    afterComponentLayout: function() {
+        var me = this,
+            width;
+
+        me.callParent(arguments);
+        if (me.autoSizing) {
+            width = me.inputEl.getWidth();
+            if (width !== me.lastInputWidth) {
+                me.fireEvent('autosize', me, width);
+                me.lastInputWidth = width;
+                delete me.autoSizing;
+            }
+        }
+    }
+});
+
+
+Ext.define('Ext.layout.component.field.TextArea', {
+    extend: 'Ext.layout.component.field.Text',
+    alias: 'layout.textareafield',
+
+    type: 'textareafield',
+    
+    canGrowWidth: false,
+    
+    naturalSizingProp: 'cols',
+    
+    beginLayout: function(ownerContext){
+        this.callParent(arguments);
+        ownerContext.target.inputEl.setStyle('height', '');
+    },
+
+    measureContentHeight: function (ownerContext) {
+        var me = this,
+            owner = me.owner,
+            height = me.callParent(arguments),
+            inputContext, inputEl, value, max, curWidth, calcHeight;
+
+        if (owner.grow && !ownerContext.state.growHandled) {
+            inputContext = ownerContext.inputContext;
+            inputEl = owner.inputEl;
+            curWidth = inputEl.getWidth(true); 
+
+            
+            value = Ext.util.Format.htmlEncode(inputEl.dom.value) || '&#160;';
+            value += owner.growAppend;
+            
+            
+            value = value.replace(/\n/g, '<br/>');
+
+            
+            calcHeight = Ext.util.TextMetrics.measure(inputEl, value, curWidth).height +
+                         inputContext.getBorderInfo().height + inputContext.getPaddingInfo().height;
+
+            
+            calcHeight = Ext.Number.constrain(calcHeight, owner.growMin, owner.growMax);
+            inputContext.setHeight(calcHeight);
+            ownerContext.state.growHandled = true;
+            
+            
+            inputContext.domBlock(me, 'height');
+            height = NaN;
+        }
+        return height;
+    }
+});
+
+
+Ext.define('Ext.form.field.TextArea', {
+    extend:'Ext.form.field.Text',
+    alias: ['widget.textareafield', 'widget.textarea'],
+    alternateClassName: 'Ext.form.TextArea',
+    requires: [
+        'Ext.XTemplate', 
+        'Ext.layout.component.field.TextArea',
+        'Ext.util.DelayedTask'
+    ],
+
+    
+    
+    
+    
+    
+    
+    
+    fieldSubTpl: [
+        '<textarea id="{id}" {inputAttrTpl}',
+            '<tpl if="name"> name="{name}"</tpl>',
+            '<tpl if="rows"> rows="{rows}" </tpl>',
+            '<tpl if="cols"> cols="{cols}" </tpl>',
+            '<tpl if="placeholder"> placeholder="{placeholder}"</tpl>',
+            '<tpl if="size"> size="{size}"</tpl>',
+            '<tpl if="maxLength !== undefined"> maxlength="{maxLength}"</tpl>',
+            '<tpl if="readOnly"> readonly="readonly"</tpl>',
+            '<tpl if="disabled"> disabled="disabled"</tpl>',
+            '<tpl if="tabIdx"> tabIndex="{tabIdx}"</tpl>',
+            ' class="{fieldCls} {typeCls}" ',
+            '<tpl if="fieldStyle"> style="{fieldStyle}"</tpl>',
+            ' autocomplete="off">\n',
+            '<tpl if="value">{[Ext.util.Format.htmlEncode(values.value)]}</tpl>',
+        '</textarea>',
+        {
+            disableFormats: true
+        }
+    ],
+
+    
+    growMin: 60,
+
+    
+    growMax: 1000,
+
+    
+    growAppend: '\n-',
+
+    
+    cols: 20,
+
+    
+    rows: 4,
+
+    
+    enterIsSpecial: false,
+
+    
+    preventScrollbars: false,
+
+    
+    componentLayout: 'textareafield',
+    
+    setGrowSizePolicy: Ext.emptyFn,
+    
+    returnRe: /\r/g,
+
+    
+    getSubTplData: function() {
+        var me = this,
+            fieldStyle = me.getFieldStyle(),
+            ret = me.callParent();
+
+        if (me.grow) {
+            if (me.preventScrollbars) {
+                ret.fieldStyle = (fieldStyle||'') + ';overflow:hidden;height:' + me.growMin + 'px';
+            }
+        }
+
+        Ext.applyIf(ret, {
+            cols: me.cols,
+            rows: me.rows
+        });
+
+        return ret;
+    },
+
+    afterRender: function () {
+        var me = this;
+
+        me.callParent(arguments);
+
+        me.needsMaxCheck = me.enforceMaxLength && me.maxLength !== Number.MAX_VALUE && !Ext.supports.TextAreaMaxLength;
+        if (me.needsMaxCheck) {
+            me.inputEl.on('paste', me.onPaste, me);
+        }
+    },
+    
+    
+    
+    
+    
+    
+    
+    transformRawValue: function(value){
+        return this.stripReturns(value);
+    },
+    
+    transformOriginalValue: function(value){
+        return this.stripReturns(value); 
+    },
+    
+    valueToRaw: function(value){
+        value = this.stripReturns(value);
+        return this.callParent([value]);
+    },
+    
+    stripReturns: function(value){
+        if (value) {
+            value = value.replace(this.returnRe, '');
+        }
+        return value;
+    },
+
+    onPaste: function(e){
+        var me = this;
+        if (!me.pasteTask) {
+            me.pasteTask = new Ext.util.DelayedTask(me.pasteCheck, me);
+        }
+        
+        me.pasteTask.delay(1);
+    },
+    
+    pasteCheck: function(){
+        var me = this,
+            value = me.getValue(),
+            max = me.maxLength;
+            
+        if (value.length > max) {
+            value = value.substr(0, max);
+            me.setValue(value);
+        }
+    },
+
+    
+    fireKey: function(e) {
+        var me = this,
+            key = e.getKey(),
+            value;
+            
+        if (e.isSpecialKey() && (me.enterIsSpecial || (key !== e.ENTER || e.hasModifier()))) {
+            me.fireEvent('specialkey', me, e);
+        }
+        
+        if (me.needsMaxCheck && key !== e.BACKSPACE && key !== e.DELETE && !e.isNavKeyPress() && !me.isCutCopyPasteSelectAll(e, key)) {
+            value = me.getValue();
+            if (value.length >= me.maxLength) {
+                e.stopEvent();
+            }
+        }
+    },
+    
+    isCutCopyPasteSelectAll: function(e, key) {
+        if (e.CTRL) {
+            return key === e.A || key === e.C || key === e.V || key === e.X;
+        }
+        return false;
+    },
+
+    
+    autoSize: function() {
+        var me = this,
+            height;
+
+        if (me.grow && me.rendered) {
+            me.updateLayout();
+            height = me.inputEl.getHeight();
+            if (height !== me.lastInputHeight) {
+                
+                me.fireEvent('autosize', me, height);
+                me.lastInputHeight = height;
+            }
+        }
+    },
+
+    
+    initAria: function() {
+        this.callParent(arguments);
+        this.getActionEl().dom.setAttribute('aria-multiline', true);
+    },
+    
+    beforeDestroy: function(){
+        var task = this.pasteTask;
+        if (task) {
+            task.delay();
+        }    
+        this.callParent();
+    }
+});
+
+
+Ext.define('Ext.form.field.Display', {
+    extend:'Ext.form.field.Base',
+    alias: 'widget.displayfield',
+    requires: ['Ext.util.Format', 'Ext.XTemplate'],
+    alternateClassName: ['Ext.form.DisplayField', 'Ext.form.Display'],
+    fieldSubTpl: [
+        '<div id="{id}"',
+        '<tpl if="fieldStyle"> style="{fieldStyle}"</tpl>', 
+        ' class="{fieldCls}">{value}</div>',
+        {
+            compiled: true,
+            disableFormats: true
+        }
+    ],
+
+    
+    fieldCls: Ext.baseCSSPrefix + 'form-display-field',
+
+    
+    htmlEncode: false,
+    
+    
+    
+    
+
+    validateOnChange: false,
+
+    initEvents: Ext.emptyFn,
+
+    submitValue: false,
+    
+    isDirty: function(){
+        return false;
+    },
+
+    isValid: function() {
+        return true;
+    },
+
+    validate: function() {
+        return true;
+    },
+
+    getRawValue: function() {
+        return this.rawValue;
+    },
+
+    setRawValue: function(value) {
+        var me = this,
+            display;
+            
+        value = Ext.value(value, '');
+        me.rawValue = value;
+        if (me.rendered) {
+            me.inputEl.dom.innerHTML = me.getDisplayValue();
+            me.updateLayout();
+        }
+        return value;
+    },
+
+    
+    getDisplayValue: function() {
+        var me = this,
+            value = this.getRawValue(),
+            display;
+        if (me.renderer) {
+             display = me.renderer.call(me.scope || me, value, me);
+        } else {
+             display = me.htmlEncode ? Ext.util.Format.htmlEncode(value) : value;
+        }
+        return display;
+    },
+        
+    getSubTplData: function() {
+        var ret = this.callParent(arguments);
+
+        ret.value = this.getDisplayValue();
+
+        return ret;
+    }
+
+    
+    
+    
+    
+    
+    
+});
+
+
+Ext.define('Ext.layout.container.Anchor', {
+
+    
+
+    alias: 'layout.anchor',
+    extend: 'Ext.layout.container.Container',
+    alternateClassName: 'Ext.layout.AnchorLayout',
+
+    
+
+    type: 'anchor',
+
+    manageOverflow: 2,
+
+    renderTpl: [
+        '{%this.renderBody(out,values);this.renderPadder(out,values)%}'
+    ],
+
+    
+
+    
+    defaultAnchor: '100%',
+
+    parseAnchorRE: /^(r|right|b|bottom)$/i,
+
+    beginLayout: function (ownerContext) {
+        var me = this,
+            dimensions = 0,
+            anchorSpec, childContext, childItems, i, length, target;
+
+        me.callParent(arguments);
+
+        childItems = ownerContext.childItems; 
+        length = childItems.length;
+
+        for (i = 0; i < length; ++i) {
+            childContext = childItems[i];
+            anchorSpec = childContext.target.anchorSpec;
+
+            if (anchorSpec) {
+                if (childContext.widthModel.calculated && anchorSpec.right) {
+                    dimensions |= 1;
+                }
+                if (childContext.heightModel.calculated && anchorSpec.bottom) {
+                    dimensions |= 2;
+                }
+
+                if (dimensions == 3) { 
+                    break;
+                }
+            }
+        }
+
+        ownerContext.anchorDimensions = dimensions;
+
+        
+        
+        if (!Ext.supports.RightMargin && !me.rightMarginCleanerFn) {
+            target = ownerContext.targetContext.el; 
+
+            me.rightMarginCleanerFn = Ext.Element.getRightMarginFixCleaner(target);
+            target.addCls(Ext.baseCSSPrefix + 'inline-children');
+        }
+
+    },
+
+    calculate: function (ownerContext) {
+        var me = this,
+            containerSize = me.getContainerSize(ownerContext);
+
+        if (ownerContext.anchorDimensions !== ownerContext.state.calculatedAnchors) {
+            me.calculateAnchors(ownerContext, containerSize);
+        }
+
+        if (ownerContext.hasDomProp('containerChildrenDone')) {
+            
+
+            if (!containerSize.gotAll) {
+                me.done = false;
+            }
+
+            me.calculateContentSize(ownerContext, ownerContext.anchorDimensions);
+
+            if (me.done) {
+                me.calculateOverflow(ownerContext, containerSize, ownerContext.anchorDimensions);
+                return;
+            }
+        }
+
+        me.done = false;
+    },
+
+    calculateAnchors: function (ownerContext, containerSize) {
+        var me = this,
+            childItems = ownerContext.childItems,
+            length = childItems.length,
+            gotHeight = containerSize.gotHeight,
+            gotWidth = containerSize.gotWidth,
+            ownerHeight = containerSize.height,
+            ownerWidth = containerSize.width,
+            state = ownerContext.state,
+            calculatedAnchors = (gotWidth ? 1 : 0) | (gotHeight ? 2 : 0),
+            anchorSpec, childContext, childMargins, height, i, width;
+
+        state.calculatedAnchors = (state.calculatedAnchors || 0) | calculatedAnchors;
+
+        for (i = 0; i < length; i++) {
+            childContext = childItems[i];
+            childMargins = childContext.getMarginInfo();
+            anchorSpec = childContext.target.anchorSpec;
+
+            
+            
+            
+            
+            if (gotWidth && childContext.widthModel.calculated) {
+                width = anchorSpec.right(ownerWidth) - childMargins.width;
+                width = me.adjustWidthAnchor(width, childContext);
+
+                childContext.setWidth(width);
+            }
+
+            
+            if (gotHeight && childContext.heightModel.calculated) {
+                height = anchorSpec.bottom(ownerHeight) - childMargins.height;
+                height = me.adjustHeightAnchor(height, childContext);
+
+                childContext.setHeight(height);
+            }
+        }
+    },
+
+    finishedLayout: function (ownerContext) {
+        var cleanerFn = this.rightMarginCleanerFn;
+
+        if (cleanerFn) {
+            delete this.rightMarginCleanerFn;
+            ownerContext.targetContext.el.removeCls(Ext.baseCSSPrefix + 'inline-children');
+            cleanerFn();
+        }
+    },
+
+
+    
+    anchorFactory: {
+        offset: function (delta) {
+            return function(v) {
+                return v + delta;
+            };
+        },
+        ratio: function (ratio) {
+            return function(v) {
+                return Math.floor(v * ratio);
+            };
+        },
+        standard: function (diff) {
+            return function(v) {
+                return v - diff;
+            };
+        }
+    },
+
+    parseAnchor: function(a, start, cstart) {
+        if (a && a != 'none') {
+            var factory = this.anchorFactory,
+                delta;
+
+            if (this.parseAnchorRE.test(a)) {
+                return factory.standard(cstart - start);
+            }    
+            if (a.indexOf('%') != -1) {
+                return factory.ratio(parseFloat(a.replace('%', '')) * 0.01);
+            }    
+            delta = parseInt(a, 10);
+            if (!isNaN(delta)) {
+                return factory.offset(delta);
+            }
+        }
+        return null;
+    },
+
+    
+    adjustWidthAnchor: function(value, childContext) {
+        return value;
+    },
+
+    
+    adjustHeightAnchor: function(value, childContext) {
+        return value;
+    },
+
+    configureItem: function(item) {
+        var me = this,
+            owner = me.owner,
+            anchor= item.anchor,
+            anchorsArray,
+            anchorWidth,
+            anchorHeight;
+
+        me.callParent(arguments);
+
+        if (!item.anchor && item.items && !Ext.isNumber(item.width) && !(Ext.isIE6 && Ext.isStrict)) {
+            item.anchor = anchor = me.defaultAnchor;
+        }
+
+         
+        if (owner.anchorSize) {
+            if (typeof owner.anchorSize == 'number') {
+                anchorWidth = owner.anchorSize;
+            } else {
+                anchorWidth = owner.anchorSize.width;
+                anchorHeight = owner.anchorSize.height;
+            }
+        } else {
+            anchorWidth = owner.initialConfig.width;
+            anchorHeight = owner.initialConfig.height;
+        }
+
+        if (anchor) {
+            
+            anchorsArray = anchor.split(' ');
+            item.anchorSpec = {
+                right: me.parseAnchor(anchorsArray[0], item.initialConfig.width, anchorWidth),
+                bottom: me.parseAnchor(anchorsArray[1], item.initialConfig.height, anchorHeight)
+            };
+        }
+    },
+
+    sizePolicy: {
+        '': {
+            setsWidth: 0,
+            setsHeight: 0
+        },
+        b: {
+            setsWidth: 0,
+            setsHeight: 1
+        },
+        r: {
+            '': {
+                setsWidth: 1,
+                setsHeight: 0
+            },
+            b: {
+                setsWidth: 1,
+                setsHeight: 1
+
+            }
+        }
+    },
+
+    getItemSizePolicy: function (item) {
+        var anchorSpec = item.anchorSpec,
+            key = '',
+            policy = this.sizePolicy,
+            sizeModel;
+
+        if (anchorSpec) {
+            sizeModel = this.owner.getSizeModel();
+            if (anchorSpec.right && !sizeModel.width.shrinkWrap) {
+                policy = policy.r;
+            }
+            if (anchorSpec.bottom && !sizeModel.height.shrinkWrap) {
+                key = 'b';
+            }
+        }
+
+        return policy[key];
+    }
+});
+
+
+Ext.define('Ext.window.MessageBox', {
+    extend: 'Ext.window.Window',
+
+    requires: [
+        'Ext.toolbar.Toolbar',
+        'Ext.form.field.Text',
+        'Ext.form.field.TextArea',
+        'Ext.form.field.Display',
+        'Ext.button.Button',
+        'Ext.layout.container.Anchor',
+        'Ext.layout.container.HBox',
+        'Ext.ProgressBar'
+    ],
+
+    alias: 'widget.messagebox',
+
+    
+    OK : 1,
+    
+    YES : 2,
+    
+    NO : 4,
+    
+    CANCEL : 8,
+    
+    OKCANCEL : 9,
+    
+    YESNO : 6,
+    
+    YESNOCANCEL : 14,
+    
+    INFO : Ext.baseCSSPrefix + 'message-box-info',
+    
+    WARNING : Ext.baseCSSPrefix + 'message-box-warning',
+    
+    QUESTION : Ext.baseCSSPrefix + 'message-box-question',
+    
+    ERROR : Ext.baseCSSPrefix + 'message-box-error',
+
+    
+    hideMode: 'offsets',
+    closeAction: 'hide',
+    resizable: false,
+    title: '&#160;',
+
+    width: 600,
+    height: 500,
+    minWidth: 250,
+    maxWidth: 600,
+    minHeight: 110,
+    maxHeight: 500,
+    constrain: true,
+
+    cls: Ext.baseCSSPrefix + 'message-box',
+
+    layout: {
+        type: 'vbox',
+        align: 'stretch'
+    },
+
+    
+    defaultTextHeight : 75,
+    
+    minProgressWidth : 250,
+    
+    minPromptWidth: 250,
+    
+    
+    buttonText: {
+        ok: 'OK',
+        yes: 'Yes',
+        no: 'No',
+        cancel: 'Cancel'
+    },
+    
+
+    buttonIds: [
+        'ok', 'yes', 'no', 'cancel'
+    ],
+
+    
+    titleText: {
+        confirm: 'Confirm',
+        prompt: 'Prompt',
+        wait: 'Loading...',
+        alert: 'Attention'
+    },
+    
+
+    iconHeight: 35,
+
+    makeButton: function(btnIdx) {
+        var btnId = this.buttonIds[btnIdx];
+        return new Ext.button.Button({
+            handler: this.btnCallback,
+            itemId: btnId,
+            scope: this,
+            text: this.buttonText[btnId],
+            minWidth: 75
+        });
+    },
+
+    btnCallback: function(btn) {
+        var me = this,
+            value,
+            field;
+
+        if (me.cfg.prompt || me.cfg.multiline) {
+            if (me.cfg.multiline) {
+                field = me.textArea;
+            } else {
+                field = me.textField;
+            }
+            value = field.getValue();
+            field.reset();
+        }
+
+        
+        btn.blur();
+        me.hide();
+        me.userCallback(btn.itemId, value, me.cfg);
+    },
+
+    hide: function() {
+        var me = this;
+        me.dd.endDrag();
+        me.progressBar.reset();
+        me.removeCls(me.cfg.cls);
+        me.callParent(arguments);
+    },
+
+    initComponent: function() {
+        var me = this,
+            baseId = me.id,
+            i, button,
+            tbLayout;
+
+        me.title = '&#160;';
+
+        me.topContainer = new Ext.container.Container({
+            layout: 'hbox',
+            style: {
+                padding: '10px',
+                overflow: 'hidden'
+            },
+            items: [
+                me.iconComponent = new Ext.Component({
+                    cls: me.baseCls + '-icon',
+                    width: 50,
+                    height: me.iconHeight
+                }),
+                me.promptContainer = new Ext.container.Container({
+                    flex: 1,
+                    layout: {
+                        type: 'anchor'
+                    },
+                    items: [
+                        me.msg = new Ext.form.field.Display({
+                            id: baseId + '-displayfield',
+                            cls: me.baseCls + '-text'
+                        }),
+                        me.textField = new Ext.form.field.Text({
+                            id: baseId + '-testfield',
+                            anchor: '100%',
+                            enableKeyEvents: true,
+                            listeners: {
+                                keydown: me.onPromptKey,
+                                scope: me
+                            }
+                        }),
+                        me.textArea = new Ext.form.field.TextArea({
+                            id: baseId + '-textarea',
+                            anchor: '100%',
+                            height: 75
+                        })
+                    ]
+                })
+            ]
+        });
+        me.progressBar = new Ext.ProgressBar({
+            id: baseId + '-progressbar',
+            margins: '0 10 0 10'
+        });
+
+        me.items = [me.topContainer, me.progressBar];
+
+        
+        me.msgButtons = [];
+        for (i = 0; i < 4; i++) {
+            button = me.makeButton(i);
+            me.msgButtons[button.itemId] = button;
+            me.msgButtons.push(button);
+        }
+        me.bottomTb = new Ext.toolbar.Toolbar({
+            id: baseId + '-toolbar',
+            ui: 'footer',
+            dock: 'bottom',
+            layout: {
+                pack: 'center'
+            },
+            items: [
+                me.msgButtons[0],
+                me.msgButtons[1],
+                me.msgButtons[2],
+                me.msgButtons[3]
+            ]
+        });
+        me.dockedItems = [me.bottomTb];
+
+        
+        tbLayout = me.bottomTb.getLayout();
+        tbLayout.finishedLayout = Ext.Function.createInterceptor(tbLayout.finishedLayout, function(ownerContext) {
+            me.tbWidth = ownerContext.getProp('contentWidth');
+        });
+        me.on('close', me.onClose, me);
+
+        me.callParent();
+    },
+    
+    onClose: function(){
+        var btn = this.header.child('[type=close]');
+        
+        btn.itemId = 'cancel';
+        this.btnCallback(btn);
+        delete btn.itemId;
+    },
+
+    onPromptKey: function(textField, e) {
+        var me = this,
+            blur;
+
+        if (e.keyCode === Ext.EventObject.RETURN || e.keyCode === 10) {
+            if (me.msgButtons.ok.isVisible()) {
+                blur = true;
+                me.msgButtons.ok.handler.call(me, me.msgButtons.ok);
+            } else if (me.msgButtons.yes.isVisible()) {
+                me.msgButtons.yes.handler.call(me, me.msgButtons.yes);
+                blur = true;
+            }
+
+            if (blur) {
+                me.textField.blur();
+            }
+        }
+    },
+
+    reconfigure: function(cfg) {
+        var me = this,
+            buttons = 0,
+            hideToolbar = true,
+            initialWidth = me.maxWidth,
+            oldButtonText = me.buttonText,
+            i;
+
+        
+        me.updateButtonText();
+
+        cfg = cfg || {};
+        me.cfg = cfg;
+        if (cfg.width) {
+            initialWidth = cfg.width;
+        }
+
+        
+        delete me.defaultFocus;
+
+        
+        me.animateTarget = cfg.animateTarget || undefined;
+
+        
+        me.modal = cfg.modal !== false;
+
+        
+        if (cfg.title) {
+            me.setTitle(cfg.title||'&#160;');
+        }
+
+        
+        if (Ext.isObject(cfg.buttons)) {
+            me.buttonText = cfg.buttons;
+            buttons = 0;
+        } else {
+            me.buttonText = cfg.buttonText || me.buttonText;
+            buttons = Ext.isNumber(cfg.buttons) ? cfg.buttons : 0;
+        }
+
+        
+        
+        buttons = buttons | me.updateButtonText();
+
+        
+        me.buttonText = oldButtonText;
+
+        
+        
+        Ext.suspendLayouts();
+        me.hidden = false;
+        if (!me.rendered) {
+            me.width = initialWidth;
+            me.render(Ext.getBody());
+        } else {
+            me.setSize(initialWidth, me.maxHeight);
+        }
+
+        
+        me.closable = cfg.closable && !cfg.wait;
+        me.header.child('[type=close]').setVisible(cfg.closable !== false);
+
+        
+        if (!cfg.title && !me.closable) {
+            me.header.hide();
+        } else {
+            me.header.show();
+        }
+
+        
+        me.liveDrag = !cfg.proxyDrag;
+
+        
+        me.userCallback = Ext.Function.bind(cfg.callback ||cfg.fn || Ext.emptyFn, cfg.scope || Ext.global);
+
+        
+        me.setIcon(cfg.icon);
+
+        
+        if (cfg.msg) {
+            me.msg.setValue(cfg.msg);
+            me.msg.show();
+        } else {
+            me.msg.hide();
+        }
+
+        
+        
+        Ext.resumeLayouts(true);
+        Ext.suspendLayouts();
+
+        
+        if (cfg.prompt || cfg.multiline) {
+            me.multiline = cfg.multiline;
+            if (cfg.multiline) {
+                me.textArea.setValue(cfg.value);
+                me.textArea.setHeight(cfg.defaultTextHeight || me.defaultTextHeight);
+                me.textArea.show();
+                me.textField.hide();
+                me.defaultFocus = me.textArea;
+            } else {
+                me.textField.setValue(cfg.value);
+                me.textArea.hide();
+                me.textField.show();
+                me.defaultFocus = me.textField;
+            }
+        } else {
+            me.textArea.hide();
+            me.textField.hide();
+        }
+
+        
+        if (cfg.progress || cfg.wait) {
+            me.progressBar.show();
+            me.updateProgress(0, cfg.progressText);
+            if(cfg.wait === true){
+                me.progressBar.wait(cfg.waitConfig);
+            }
+        } else {
+            me.progressBar.hide();
+        }
+
+        
+        for (i = 0; i < 4; i++) {
+            if (buttons & Math.pow(2, i)) {
+
+                
+                if (!me.defaultFocus) {
+                    me.defaultFocus = me.msgButtons[i];
+                }
+                me.msgButtons[i].show();
+                hideToolbar = false;
+            } else {
+                me.msgButtons[i].hide();
+            }
+        }
+
+        
+        if (hideToolbar) {
+            me.bottomTb.hide();
+        } else {
+            me.bottomTb.show();
+        }
+        Ext.resumeLayouts(true);
+    },
+
+    
+    updateButtonText: function() {
+        var me = this,
+            buttonText = me.buttonText,
+            buttons = 0,
+            btnId,
+            btn;
+
+        for (btnId in buttonText) {
+            if (buttonText.hasOwnProperty(btnId)) {
+                btn = me.msgButtons[btnId];
+                if (btn) {
+                    if (me.cfg && me.cfg.buttonText) {
+                        buttons = buttons | Math.pow(2, Ext.Array.indexOf(me.buttonIds, btnId));
+                    }
+                    if (btn.text != buttonText[btnId]) {
+                        btn.setText(buttonText[btnId]);
+                    }
+                }
+            }
+        }
+        return buttons;
+    },
+
+    
+    show: function(cfg) {
+        var me = this;
+
+        me.reconfigure(cfg);
+        me.addCls(cfg.cls);
+        me.doAutoSize();
+
+        
+        
+        me.hidden = true;
+        me.callParent();
+        return me;
+    },
+
+    onShow: function() {
+        this.callParent(arguments);
+        this.center();
+    },
+
+    doAutoSize: function() {
+        var me = this,
+            headerVisible = me.header.rendered && me.header.isVisible(),
+            footerVisible = me.bottomTb.rendered && me.bottomTb.isVisible(),
+            width,
+            height;
+
+        if (!Ext.isDefined(me.frameWidth)) {
+            me.frameWidth = me.el.getWidth() - me.body.getWidth();
+        }
+
+        
+        me.minWidth = me.cfg.minWidth || Ext.getClass(this).prototype.minWidth;
+
+        
+        width = Math.max(
+            headerVisible ? me.header.getMinWidth() : 0,                            
+            me.cfg.width || me.msg.getWidth() + me.iconComponent.getWidth() + 25,   
+            (footerVisible ? me.tbWidth : 0)
+        );
+
+        height = (headerVisible ? me.header.getHeight() : 0) +
+            me.topContainer.getHeight() +
+            me.progressBar.getHeight() +
+            (footerVisible ? me.bottomTb.getHeight() + me.bottomTb.el.getMargin('tb') : 0);
+
+        me.setSize(width + me.frameWidth, height + me.frameWidth);
+        return me;
+    },
+
+    updateText: function(text) {
+        this.msg.setValue(text);
+        return this.doAutoSize(true);
+    },
+
+    
+    setIcon : function(icon) {
+        var me = this;
+        me.iconComponent.removeCls(me.messageIconCls);
+        if (icon) {
+            me.iconComponent.show();
+            me.iconComponent.addCls(Ext.baseCSSPrefix + 'dlg-icon');
+            me.iconComponent.addCls(me.messageIconCls = icon);
+        } else {
+            me.iconComponent.removeCls(Ext.baseCSSPrefix + 'dlg-icon');
+            me.iconComponent.hide();
+        }
+        return me;
+    },
+
+    
+    updateProgress : function(value, progressText, msg){
+        this.progressBar.updateProgress(value, progressText);
+        if (msg){
+            this.updateText(msg);
+        }
+        return this;
+    },
+
+    onEsc: function() {
+        if (this.closable !== false) {
+            this.callParent(arguments);
+        }
+    },
+
+    
+    confirm: function(cfg, msg, fn, scope) {
+        if (Ext.isString(cfg)) {
+            cfg = {
+                title: cfg,
+                icon: this.QUESTION,
+                msg: msg,
+                buttons: this.YESNO,
+                callback: fn,
+                scope: scope
+            };
+        }
+        return this.show(cfg);
+    },
+
+    
+    prompt : function(cfg, msg, fn, scope, multiline, value){
+        if (Ext.isString(cfg)) {
+            cfg = {
+                prompt: true,
+                title: cfg,
+                minWidth: this.minPromptWidth,
+                msg: msg,
+                buttons: this.OKCANCEL,
+                callback: fn,
+                scope: scope,
+                multiline: multiline,
+                value: value
+            };
+        }
+        return this.show(cfg);
+    },
+
+    
+    wait : function(cfg, title, config){
+        if (Ext.isString(cfg)) {
+            cfg = {
+                title : title,
+                msg : cfg,
+                closable: false,
+                wait: true,
+                modal: true,
+                minWidth: this.minProgressWidth,
+                waitConfig: config
+            };
+        }
+        return this.show(cfg);
+    },
+
+    
+    alert: function(cfg, msg, fn, scope) {
+        if (Ext.isString(cfg)) {
+            cfg = {
+                title : cfg,
+                msg : msg,
+                buttons: this.OK,
+                fn: fn,
+                scope : scope,
+                minWidth: this.minWidth
+            };
+        }
+        return this.show(cfg);
+    },
+
+    
+    progress : function(cfg, msg, progressText){
+        if (Ext.isString(cfg)) {
+            cfg = {
+                title: cfg,
+                msg: msg,
+                progress: true,
+                progressText: progressText
+            };
+        }
+        return this.show(cfg);
+    }
+}, function() {
+    
+    Ext.MessageBox = Ext.Msg = new this();
+});
+
+
+Ext.define('Ext.form.Basic', {
+    extend: 'Ext.util.Observable',
+    alternateClassName: 'Ext.form.BasicForm',
+    requires: ['Ext.util.MixedCollection', 'Ext.form.action.Load', 'Ext.form.action.Submit',
+               'Ext.window.MessageBox', 'Ext.data.Errors', 'Ext.util.DelayedTask'],
+
+    
+    constructor: function(owner, config) {
+        var me = this,
+            onItemAddOrRemove = me.onItemAddOrRemove,
+            api,
+            fn;
+
+        
+        me.owner = owner;
+
+        
+        me.mon(owner, {
+            add: onItemAddOrRemove,
+            remove: onItemAddOrRemove,
+            scope: me
+        });
+
+        Ext.apply(me, config);
+
+        
+        if (Ext.isString(me.paramOrder)) {
+            me.paramOrder = me.paramOrder.split(/[\s,|]/);
+        }
+        
+        if (me.api) {
+            api = me.api = Ext.apply({}, me.api);
+            for (fn in api) {
+                if (api.hasOwnProperty(fn)) {
+                    api[fn] = Ext.direct.Manager.parseMethod(api[fn]);
+                }
+            }
+        }
+
+        me.checkValidityTask = new Ext.util.DelayedTask(me.checkValidity, me);
+
+        me.addEvents(
+            
+            'beforeaction',
+            
+            'actionfailed',
+            
+            'actioncomplete',
+            
+            'validitychange',
+            
+            'dirtychange'
+        );
+        me.callParent();
+    },
+
+    
+    initialize : function() {
+        var me = this;
+        me.initialized = true;
+        me.onValidityChange(!me.hasInvalidField());
+    },
+
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+    timeout: 30,
+
+    
+
+    
+
+    
+    paramsAsHash: false,
+
+    
+    
+    waitTitle: 'Please Wait...',
+    
+
+    
+    trackResetOnLoad: false,
+
+    
+
+    
+
+
+    
+    wasDirty: false,
+
+
+    
+    destroy: function() {
+        this.clearListeners();
+        this.checkValidityTask.cancel();
+    },
+
+    
+    onItemAddOrRemove: function(parent, child) {
+        var me = this,
+            isAdding = !!child.ownerCt,
+            isContainer = child.isContainer;
+
+        function handleField(field) {
+            
+            me[isAdding ? 'mon' : 'mun'](field, {
+                validitychange: me.checkValidity,
+                dirtychange: me.checkDirty,
+                scope: me,
+                buffer: 100 
+            });
+            
+            delete me._fields;
+        }
+
+        if (child.isFormField) {
+            handleField(child);
+        } else if (isContainer) {
+            
+            if (child.isDestroyed || child.destroying) {
+                
+                
+                delete me._fields;
+            } else {
+                Ext.Array.forEach(child.query('[isFormField]'), handleField);
+            }
+        }
+
+        
+        delete this._boundItems;
+
+        
+        
+        if (me.initialized) {
+            me.checkValidityTask.delay(10);
+        }
+    },
+
+    
+    getFields: function() {
+        var fields = this._fields;
+        if (!fields) {
+            fields = this._fields = new Ext.util.MixedCollection();
+            fields.addAll(this.owner.query('[isFormField]'));
+        }
+        return fields;
+    },
+
+    
+    getBoundItems: function() {
+        var boundItems = this._boundItems;
+        
+        if (!boundItems || boundItems.getCount() === 0) {
+            boundItems = this._boundItems = new Ext.util.MixedCollection();
+            boundItems.addAll(this.owner.query('[formBind]'));
+        }
+        
+        return boundItems;
+    },
+
+    
+    hasInvalidField: function() {
+        return !!this.getFields().findBy(function(field) {
+            var preventMark = field.preventMark,
+                isValid;
+            field.preventMark = true;
+            isValid = field.isValid();
+            field.preventMark = preventMark;
+            return !isValid;
+        });
+    },
+
+    
+    isValid: function() {
+        var me = this,
+            invalid;
+        Ext.suspendLayouts();
+        invalid = me.getFields().filterBy(function(field) {
+            return !field.validate();
+        });
+        Ext.resumeLayouts(true);
+        return invalid.length < 1;
+    },
+
+    
+    checkValidity: function() {
+        var me = this,
+            valid = !me.hasInvalidField();
+        if (valid !== me.wasValid) {
+            me.onValidityChange(valid);
+            me.fireEvent('validitychange', me, valid);
+            me.wasValid = valid;
+        }
+    },
+
+    
+    onValidityChange: function(valid) {
+        var boundItems = this.getBoundItems(),
+            items, i, iLen, cmp;
+
+        if (boundItems) {
+            items = boundItems.items;
+            iLen  = items.length;
+
+            for (i = 0; i < iLen; i++) {
+                cmp = items[i];
+
+                if (cmp.disabled === valid) {
+                    cmp.setDisabled(!valid);
+                }
+            }
+        }
+    },
+
+    
+    isDirty: function() {
+        return !!this.getFields().findBy(function(f) {
+            return f.isDirty();
+        });
+    },
+
+    
+    checkDirty: function() {
+        var dirty = this.isDirty();
+        if (dirty !== this.wasDirty) {
+            this.fireEvent('dirtychange', this, dirty);
+            this.wasDirty = dirty;
+        }
+    },
+
+    
+    hasUpload: function() {
+        return !!this.getFields().findBy(function(f) {
+            return f.isFileUpload();
+        });
+    },
+
+    
+    doAction: function(action, options) {
+        if (Ext.isString(action)) {
+            action = Ext.ClassManager.instantiateByAlias('formaction.' + action, Ext.apply({}, options, {form: this}));
+        }
+        if (this.fireEvent('beforeaction', this, action) !== false) {
+            this.beforeAction(action);
+            Ext.defer(action.run, 100, action);
+        }
+        return this;
+    },
+
+    
+    submit: function(options) {
+        options = options || {};
+        var me = this,
+            action;
+            
+        if (options.standardSubmit || me.standardSubmit) {
+            action = 'standardsubmit';
+        } else {
+            action = me.api ? 'directsubmit' : 'submit';
+        }
+            
+        return me.doAction(action, options);
+    },
+
+    
+    load: function(options) {
+        return this.doAction(this.api ? 'directload' : 'load', options);
+    },
+
+    
+    updateRecord: function(record) {
+        record = record || this._record;
+        var fields = record.fields.items,
+            values = this.getFieldValues(),
+            obj = {},
+            i = 0,
+            len = fields.length,
+            name;
+
+        for (; i < len; ++i) {
+            name  = fields[i].name;
+
+            if (values.hasOwnProperty(name)) {
+                obj[name] = values[name];
+            }
+        }
+
+        record.beginEdit();
+        record.set(obj);
+        record.endEdit();
+
+        return this;
+    },
+
+    
+    loadRecord: function(record) {
+        this._record = record;
+        return this.setValues(record.data);
+    },
+
+    
+    getRecord: function() {
+        return this._record;
+    },
+
+    
+    beforeAction: function(action) {
+        var waitMsg = action.waitMsg,
+            maskCls = Ext.baseCSSPrefix + 'mask-loading',
+            fields  = this.getFields().items,
+            f,
+            fLen    = fields.length,
+            field, waitMsgTarget;
+
+        
+        for (f = 0; f < fLen; f++) {
+            field = fields[f];
+
+            if (field.isFormField && field.syncValue) {
+                field.syncValue();
+            }
+        }
+
+        if (waitMsg) {
+            waitMsgTarget = this.waitMsgTarget;
+            if (waitMsgTarget === true) {
+                this.owner.el.mask(waitMsg, maskCls);
+            } else if (waitMsgTarget) {
+                waitMsgTarget = this.waitMsgTarget = Ext.get(waitMsgTarget);
+                waitMsgTarget.mask(waitMsg, maskCls);
+            } else {
+                Ext.MessageBox.wait(waitMsg, action.waitTitle || this.waitTitle);
+            }
+        }
+    },
+
+    
+    afterAction: function(action, success) {
+        if (action.waitMsg) {
+            var messageBox = Ext.MessageBox,
+                waitMsgTarget = this.waitMsgTarget;
+            if (waitMsgTarget === true) {
+                this.owner.el.unmask();
+            } else if (waitMsgTarget) {
+                waitMsgTarget.unmask();
+            } else {
+                
+                
+                messageBox.suspendEvents();
+                messageBox.hide();
+                messageBox.resumeEvents();
+            }
+        }
+        if (success) {
+            if (action.reset) {
+                this.reset();
+            }
+            Ext.callback(action.success, action.scope || action, [this, action]);
+            this.fireEvent('actioncomplete', this, action);
+        } else {
+            Ext.callback(action.failure, action.scope || action, [this, action]);
+            this.fireEvent('actionfailed', this, action);
+        }
+    },
+
+
+    
+    findField: function(id) {
+        return this.getFields().findBy(function(f) {
+            return f.id === id || f.getName() === id;
+        });
+    },
+
+
+    
+    markInvalid: function(errors) {
+        var me = this,
+            e, eLen, error, value,
+            key;
+
+        function mark(fieldId, msg) {
+            var field = me.findField(fieldId);
+            if (field) {
+                field.markInvalid(msg);
+            }
+        }
+
+        if (Ext.isArray(errors)) {
+            eLen = errors.length;
+
+            for (e = 0; e < eLen; e++) {
+                error = errors[e];
+                mark(error.id, error.msg);
+            }
+        } else if (errors instanceof Ext.data.Errors) {
+            eLen  = errors.items.length;
+            for (e = 0; e < eLen; e++) {
+                error = errors.items[e];
+
+                mark(error.field, error.message);
+            }
+        } else {
+            for (key in errors) {
+                if (errors.hasOwnProperty(key)) {
+                    value = errors[key];
+                    mark(key, value, errors);
+                }
+            }
+        }
+        return this;
+    },
+
+    
+    setValues: function(values) {
+        var me = this,
+            v, vLen, val, field;
+
+        function setVal(fieldId, val) {
+            var field = me.findField(fieldId);
+            if (field) {
+                field.setValue(val);
+                if (me.trackResetOnLoad) {
+                    field.resetOriginalValue();
+                }
+            }
+        }
+
+        if (Ext.isArray(values)) {
+            
+            vLen = values.length;
+
+            for (v = 0; v < vLen; v++) {
+                val = values[v];
+
+                setVal(val.id, val.value);
+            }
+        } else {
+            
+            Ext.iterate(values, setVal);
+        }
+        return this;
+    },
+
+    
+    getValues: function(asString, dirtyOnly, includeEmptyText, useDataValues) {
+        var values  = {},
+            fields  = this.getFields().items,
+            f,
+            fLen    = fields.length,
+            isArray = Ext.isArray,
+            field, data, val, bucket, name;
+
+        for (f = 0; f < fLen; f++) {
+            field = fields[f];
+
+            if (!dirtyOnly || field.isDirty()) {
+                data = field[useDataValues ? 'getModelData' : 'getSubmitData'](includeEmptyText);
+
+                if (Ext.isObject(data)) {
+                    for (name in data) {
+                        if (data.hasOwnProperty(name)) {
+                            val = data[name];
+
+                            if (includeEmptyText && val === '') {
+                                val = field.emptyText || '';
+                            }
+
+                            if (values.hasOwnProperty(name)) {
+                                bucket = values[name];
+
+                                if (!isArray(bucket)) {
+                                    bucket = values[name] = [bucket];
+                                }
+
+                                if (isArray(val)) {
+                                    values[name] = values[name] = bucket.concat(val);
+                                } else {
+                                    bucket.push(val);
+                                }
+                            } else {
+                                values[name] = val;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if (asString) {
+            values = Ext.Object.toQueryString(values);
+        }
+        return values;
+    },
+
+    
+    getFieldValues: function(dirtyOnly) {
+        return this.getValues(false, dirtyOnly, false, true);
+    },
+
+    
+    clearInvalid: function() {
+        Ext.suspendLayouts();
+
+        var me     = this,
+            fields = me.getFields().items,
+            f,
+            fLen   = fields.length;
+
+        for (f = 0; f < fLen; f++) {
+            fields[f].clearInvalid();
+        }
+
+        Ext.resumeLayouts(true);
+        return me;
+    },
+
+    
+    reset: function() {
+        Ext.suspendLayouts();
+
+        var me     = this,
+            fields = me.getFields().items,
+            f,
+            fLen   = fields.length;
+
+        for (f = 0; f < fLen; f++) {
+            fields[f].reset();
+        }
+
+        Ext.resumeLayouts(true);
+        return me;
+    },
+
+    
+    applyToFields: function(obj) {
+        var fields = this.getFields().items,
+            f,
+            fLen   = fields.length;
+
+        for (f = 0; f < fLen; f++) {
+            Ext.apply(fields[f], obj);
+        }
+
+        return this;
+    },
+
+    
+    applyIfToFields: function(obj) {
+        var fields = this.getFields().items,
+            f,
+            fLen   = fields.length;
+
+        for (f = 0; f < fLen; f++) {
+            Ext.applyIf(fields[f], obj);
+        }
+
+        return this;
+    }
+});
+
+
+Ext.define('Ext.layout.container.CheckboxGroup', {
+    extend: 'Ext.layout.container.Container',
+    alias: ['layout.checkboxgroup'],
+
+    
+    autoFlex: true,
+
+    type: 'checkboxgroup',
+
+    childEls: [
+        'innerCt'
+    ],
+
+    renderTpl: [
+        '<table id="{ownerId}-innerCt" role="presentation" style="{tableStyle}"><tbody><tr>',
+            '<tpl for="columns">',
+                '<td class="{parent.colCls}" valign="top" style="{style}">',
+                    '{% this.renderColumn(out,parent,xindex-1) %}',
+                '</td>',
+            '</tpl>',
+        '</tr></tbody></table>'
+    ],
+
+    lastOwnerItemsGeneration : null,
+
+    beginLayout: function(ownerContext) {
+        var me = this,
+            columns,
+            numCols,
+            i, width, cwidth,
+            totalFlex = 0, flexedCols = 0,
+            autoFlex = me.autoFlex,
+            innerCtStyle = me.innerCt.dom.style;
+
+        me.callParent(arguments);
+
+        columns = me.columnNodes;
+        ownerContext.innerCtContext = ownerContext.getEl('innerCt', me);
+
+        
+        if (!ownerContext.widthModel.shrinkWrap) {
+            numCols = columns.length;
+
+            
+            if (me.columnsArray) {
+
+                
+                for (i = 0; i < numCols; i++) {
+                    width = me.owner.columns[i];
+                    if (width < 1) {
+                        totalFlex += width;
+                        flexedCols++;
+                    }
+                }
+
+                
+                for (i = 0; i < numCols; i++) {
+                    width = me.owner.columns[i];
+                    if (width < 1) {
+                        cwidth = ((width / totalFlex) * 100) + '%';
+                    } else {
+                        cwidth = width + 'px';
+                    }
+                    columns[i].style.width = cwidth;
+                }
+            }
+
+            
+            else {
+                for (i = 0; i < numCols; i++) {
+                    
+                    
+                    
+                    cwidth = autoFlex
+                        ? (1 / numCols * 100) + '%'
+                        : '';
+                    columns[i].style.width = cwidth;
+                    flexedCols++;
+                }
+            }
+
+            
+            if (!flexedCols) {
+                innerCtStyle.tableLayout = 'fixed';
+                innerCtStyle.width = '';
+            
+            } else if (flexedCols < numCols) {
+                innerCtStyle.tableLayout = 'fixed';
+                innerCtStyle.width = '100%';
+            
+            } else {
+                innerCtStyle.tableLayout = 'auto';
+                
+                if (autoFlex) {
+                    innerCtStyle.width = '100%';
+                } else {
+                    innerCtStyle.width = '';
+                }
+            }
+
+        } else {
+            innerCtStyle.tableLayout = 'auto';
+            innerCtStyle.width = '';
+        }
+    },
+
+    cacheElements: function () {
+        var me = this;
+
+        
+        me.callParent();
+
+        me.rowEl = me.innerCt.down('tr');
+
+        
+        me.columnNodes = me.rowEl.dom.childNodes;
+    },
+
+    
+    calculate: function(ownerContext) {
+        var me = this,
+            targetContext, widthShrinkWrap, heightShrinkWrap, shrinkWrap, table, targetPadding;
+
+        
+        
+        if (!ownerContext.getDomProp('containerChildrenDone')) {
+            me.done = false;
+        } else {
+            targetContext = ownerContext.innerCtContext;
+            widthShrinkWrap = ownerContext.widthModel.shrinkWrap;
+            heightShrinkWrap = ownerContext.heightModel.shrinkWrap;
+            shrinkWrap = heightShrinkWrap || widthShrinkWrap;
+            table = targetContext.el.dom;
+            targetPadding = shrinkWrap && targetContext.getPaddingInfo();
+
+            if (widthShrinkWrap) {
+                ownerContext.setContentWidth(table.offsetWidth + targetPadding.width, true);
+            }
+
+            if (heightShrinkWrap) {
+                ownerContext.setContentHeight(table.offsetHeight + targetPadding.height, true);
+            }
+        }
+    },
+
+    doRenderColumn: function (out, renderData, columnIndex) {
+        
+        
+
+        var me = renderData.$layout,
+            owner = me.owner,
+            columnCount = renderData.columnCount,
+            items = owner.items.items,
+            itemCount = items.length,
+            item, itemIndex, rowCount, increment, tree;
+
+        
+        
+        
+
+        if (owner.vertical) {
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+
+            rowCount = Math.ceil(itemCount / columnCount); 
+            itemIndex = columnIndex * rowCount;
+            itemCount = Math.min(itemCount, itemIndex + rowCount);
+            increment = 1;
+        } else {
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+
+            itemIndex = columnIndex;
+            increment = columnCount;
+        }
+
+        for ( ; itemIndex < itemCount; itemIndex += increment) {
+            item = items[itemIndex];
+            me.configureItem(item);
+            tree = item.getRenderTree();
+            Ext.DomHelper.generateMarkup(tree, out);
+        }
+    },
+
+    
+    getColumnCount: function() {
+        var me = this,
+            owner = me.owner,
+            ownerColumns = owner.columns;
+
+        
+        
+        if (me.columnsArray) {
+            return ownerColumns.length;
+        }
+
+        if (Ext.isNumber(ownerColumns)) {
+            return ownerColumns;
+        }
+        return owner.items.length;
+    },
+
+    getItemSizePolicy: function (item) {
+        return this.autoSizePolicy;
+    },
+
+    getRenderData: function () {
+        var me = this,
+            data = me.callParent(),
+            owner = me.owner,
+            i, columns = me.getColumnCount(),
+            width, column, cwidth,
+            autoFlex = me.autoFlex,
+            totalFlex = 0, flexedCols = 0;
+
+        
+        if (me.columnsArray) {
+            for (i=0; i < columns; i++) {
+                width = me.owner.columns[i];
+                if (width < 1) {
+                    totalFlex += width;
+                    flexedCols++;
+                }
+            }
+        }
+
+        data.colCls = owner.groupCls;
+        data.columnCount = columns;
+
+        data.columns = [];
+        for (i = 0; i < columns; i++) {
+            column = (data.columns[i] = {});
+
+            if (me.columnsArray) {
+                width = me.owner.columns[i];
+                if (width < 1) {
+                    cwidth = ((width / totalFlex) * 100) + '%';
+                } else {
+                    cwidth = width + 'px';
+                }
+                column.style = 'width:' + cwidth;
+            } else {
+                column.style = 'width:' + (1 / columns * 100) + '%';
+                flexedCols++;
+            }
+        }
+
+        
+        data.tableStyle =
+            !flexedCols ? 'table-layout:fixed;' :
+            (flexedCols < columns) ? 'table-layout:fixed;width:100%' :
+            (autoFlex) ? 'table-layout:auto;width:100%' : 'table-layout:auto;';
+
+        return data;
+    },
+
+    initLayout: function () {
+        var me = this,
+            owner = me.owner;
+
+        me.columnsArray = Ext.isArray(owner.columns);
+        me.autoColumns = !owner.columns || owner.columns === 'auto';
+        me.vertical = owner.vertical;
+
+        me.callParent();
+    },
+
+    
+    isValidParent: function() {
+        return true;
+    },
+
+    setupRenderTpl: function (renderTpl) {
+        this.callParent(arguments);
+
+        renderTpl.renderColumn = this.doRenderColumn;
+    },
+
+    renderChildren: function () {
+        var me = this,
+            generation = me.owner.items.generation;
+
+        if (me.lastOwnerItemsGeneration !== generation) {
+            me.lastOwnerItemsGeneration = generation;
+            me.renderItems(me.getLayoutItems());
+        }
+    },
+
+    
+    renderItems : function(items) {
+        var me = this,
+            itemCount = items.length,
+            i,
+            item,
+            rowCount,
+            columnCount,
+            rowIndex,
+            columnIndex;
+
+        if (itemCount) {
+            Ext.suspendLayouts();
+
+            if (me.autoColumns) {
+                me.addMissingColumns(itemCount);
+            }
+
+            columnCount = me.columnNodes.length;
+            rowCount = Math.ceil(itemCount / columnCount);
+
+            for (i = 0; i < itemCount; i++) {
+                item = items[i];
+                rowIndex = me.getRenderRowIndex(i, rowCount, columnCount);
+                columnIndex = me.getRenderColumnIndex(i, rowCount, columnCount);
+
+                if (!item.rendered) {
+                    me.renderItem(item, rowIndex, columnIndex);
+                } else if (!me.isItemAtPosition(item, rowIndex, columnIndex)) {
+                    me.moveItem(item, rowIndex, columnIndex);
+                }
+            }
+
+            if (me.autoColumns) {
+                me.removeExceedingColumns(itemCount);
+            }
+
+            Ext.resumeLayouts(true);
+        }
+    },
+
+    isItemAtPosition : function(item, rowIndex, columnIndex) {
+        return item.el.dom === this.getNodeAt(rowIndex, columnIndex);
+    },
+
+    getRenderColumnIndex : function(itemIndex, rowCount, columnCount) {
+        if (this.vertical) {
+            return Math.floor(itemIndex / rowCount);
+        } else {
+            return itemIndex % columnCount;
+        }
+    },
+
+    getRenderRowIndex : function(itemIndex, rowCount, columnCount) {
+        var me = this;
+        if (me.vertical) {
+            return itemIndex % rowCount;
+        } else {
+            return Math.floor(itemIndex / columnCount);
+        }
+    },
+
+    getNodeAt : function(rowIndex, columnIndex) {
+        return this.columnNodes[columnIndex].childNodes[rowIndex];
+    },
+
+    addMissingColumns : function(itemsCount) {
+        var me = this,
+            existingColumnsCount = me.columnNodes.length,
+            missingColumnsCount,
+            row,
+            cls,
+            i;
+        if (existingColumnsCount < itemsCount) {
+            missingColumnsCount = itemsCount - existingColumnsCount;
+            row = me.rowEl;
+            cls = me.owner.groupCls;
+            for (i = 0; i < missingColumnsCount; i++) {
+                row.createChild({
+                    cls: cls,
+                    tag: 'td',
+                    vAlign: 'top'
+                });
+            }
+        }
+    },
+
+    removeExceedingColumns : function(itemsCount) {
+        var me = this,
+            existingColumnsCount = me.columnNodes.length,
+            exceedingColumnsCount,
+            row,
+            i;
+        if (existingColumnsCount > itemsCount) {
+            exceedingColumnsCount = existingColumnsCount - itemsCount;
+            row = me.rowEl;
+            for (i = 0; i < exceedingColumnsCount; i++) {
+                row.last().remove();
+            }
+        }
+    },
+
+    
+    renderItem : function(item, rowIndex, columnIndex) {
+        var me = this;
+
+        me.configureItem(item);
+        item.render(Ext.get(me.columnNodes[columnIndex]), rowIndex);
+        me.afterRenderItem(item);
+    },
+
+    
+    moveItem : function(item, rowIndex, columnIndex) {
+        var me = this,
+            column = me.columnNodes[columnIndex],
+            targetNode = column.childNodes[rowIndex];
+        column.insertBefore(item.el.dom, targetNode || null);
+    }
+
+});
+
+
+Ext.define('Ext.layout.component.field.FieldContainer', {
+
+    
+
+    extend: 'Ext.layout.component.field.Field',
+
+    alias: 'layout.fieldcontainer',
+
+    
+
+    type: 'fieldcontainer',
+
+    waitForOuterHeightInDom: true,
+    waitForOuterWidthInDom: true,
+
+    beginLayout: function(ownerContext) {
+        this.callParent(arguments);
+
+        
+        ownerContext.hasRawContent = true;
+        ownerContext.target.bodyEl.setStyle('height', '');
+    },
+
+    measureContentHeight: function (ownerContext) {
+        
+        
+        
+        return ownerContext.hasDomProp('containerLayoutDone') ? this.callParent(arguments) : NaN;
+    },
+
+    measureContentWidth: function (ownerContext) {
+        
+        return ownerContext.hasDomProp('containerLayoutDone') ? this.callParent(arguments) : NaN;
+    },
+
+    publishInnerWidth: function (ownerContext, width) {
+        var bodyContext = ownerContext.bodyCellContext;
+        bodyContext.setWidth(bodyContext.el.getWidth(), false);
+    },
+    
+    publishInnerHeight: function (ownerContext, height) {
+        var bodyContext = ownerContext.bodyCellContext;
+        bodyContext.setHeight(height - this.measureLabelErrorHeight(ownerContext));
+    }
+});
+
+
+Ext.define('Ext.form.FieldAncestor', {
+
+    
+
+
+    
+    initFieldAncestor: function() {
+        var me = this,
+            onSubtreeChange = me.onFieldAncestorSubtreeChange;
+
+        me.addEvents(
+            
+            'fieldvaliditychange',
+
+            
+            'fielderrorchange'
+        );
+
+        
+        me.on('add', onSubtreeChange, me);
+        me.on('remove', onSubtreeChange, me);
+
+        me.initFieldDefaults();
+    },
+
+    
+    initFieldDefaults: function() {
+        if (!this.fieldDefaults) {
+            this.fieldDefaults = {};
+        }
+    },
+
+    
+    onFieldAncestorSubtreeChange: function(parent, child) {
+        var me = this,
+            isAdding = !!child.ownerCt;
+
+        function handleCmp(cmp) {
+            var isLabelable = cmp.isFieldLabelable,
+                isField = cmp.isFormField;
+            if (isLabelable || isField) {
+                if (isLabelable) {
+                    me['onLabelable' + (isAdding ? 'Added' : 'Removed')](cmp);
+                }
+                if (isField) {
+                    me['onField' + (isAdding ? 'Added' : 'Removed')](cmp);
+                }
+            }
+            else if (cmp.isContainer) {
+                Ext.Array.forEach(cmp.getRefItems(), handleCmp);
+            }
+        }
+        handleCmp(child);
+    },
+
+    
+    onLabelableAdded: function(labelable) {
+        var me = this;
+
+        
+        me.mon(labelable, 'errorchange', me.handleFieldErrorChange, me, {buffer: 10});
+
+        labelable.setFieldDefaults(me.fieldDefaults);
+    },
+
+    
+    onFieldAdded: function(field) {
+        var me = this;
+        me.mon(field, 'validitychange', me.handleFieldValidityChange, me);
+    },
+
+    
+    onLabelableRemoved: function(labelable) {
+        var me = this;
+        me.mun(labelable, 'errorchange', me.handleFieldErrorChange, me);
+    },
+
+    
+    onFieldRemoved: function(field) {
+        var me = this;
+        me.mun(field, 'validitychange', me.handleFieldValidityChange, me);
+    },
+
+    
+    handleFieldValidityChange: function(field, isValid) {
+        var me = this;
+        me.fireEvent('fieldvaliditychange', me, field, isValid);
+        me.onFieldValidityChange(field, isValid);
+    },
+
+    
+    handleFieldErrorChange: function(labelable, activeError) {
+        var me = this;
+        me.fireEvent('fielderrorchange', me, labelable, activeError);
+        me.onFieldErrorChange(labelable, activeError);
+    },
+
+    
+    onFieldValidityChange: Ext.emptyFn,
+
+    
+    onFieldErrorChange: Ext.emptyFn
+
+});
+
+
+Ext.define('Ext.form.FieldContainer', {
+    extend: 'Ext.container.Container',
+    mixins: {
+        labelable: 'Ext.form.Labelable',
+        fieldAncestor: 'Ext.form.FieldAncestor'
+    },
+    requires: 'Ext.layout.component.field.FieldContainer',
+
+    alias: 'widget.fieldcontainer',
+
+    componentLayout: 'fieldcontainer',
+    
+    componentCls: Ext.baseCSSPrefix + 'form-fieldcontainer',
+
+    
+    combineLabels: false,
+
+    
+    
+    labelConnector: ', ',
+    
+
+    
+    combineErrors: false,
+
+    maskOnDisable: false,
+
+    fieldSubTpl: '{%this.renderContainer(out,values)%}',
+
+    initComponent: function() {
+        var me = this;
+
+        
+        me.initLabelable();
+        me.initFieldAncestor();
+
+        me.callParent();
+    },
+
+    beforeRender: function(){
+        this.callParent(arguments);
+        this.beforeLabelableRender(arguments);
+    },
+
+    
+    onLabelableAdded: function(labelable) {
+        var me = this;
+        me.mixins.fieldAncestor.onLabelableAdded.call(this, labelable);
+        me.updateLabel();
+    },
+
+    
+    onLabelableRemoved: function(labelable) {
+        var me = this;
+        me.mixins.fieldAncestor.onLabelableRemoved.call(this, labelable);
+        me.updateLabel();
+    },
+
+    initRenderTpl: function() {
+        var me = this;
+        if (!me.hasOwnProperty('renderTpl')) {
+            me.renderTpl = me.getTpl('labelableRenderTpl');
+        }
+        return me.callParent();
+    },
+
+    initRenderData: function() {
+        return Ext.applyIf(this.callParent(), this.getLabelableRenderData());
+    },
+
+    
+    getFieldLabel: function() {
+        var label = this.fieldLabel || '';
+        if (!label && this.combineLabels) {
+            label = Ext.Array.map(this.query('[isFieldLabelable]'), function(field) {
+                return field.getFieldLabel();
+            }).join(this.labelConnector);
+        }
+        return label;
+    },
+
+    getSubTplData: function() {
+        var ret = this.initRenderData();
+
+        Ext.apply(ret, this.subTplData);
+        return ret;
+    },
+
+    getSubTplMarkup: function() {
+        var me = this,
+            tpl = me.getTpl('fieldSubTpl'),
+            html;
+
+        if (!tpl.renderContent) {
+            me.setupRenderTpl(tpl);
+        }
+
+        html = tpl.apply(me.getSubTplData());
+        return html;
+    },
+
+    
+    updateLabel: function() {
+        var me = this,
+            label = me.labelEl;
+        if (label) {
+            me.setFieldLabel(me.getFieldLabel());
+        }
+    },
+
+
+    
+    onFieldErrorChange: function(field, activeError) {
+        if (this.combineErrors) {
+            var me = this,
+                oldError = me.getActiveError(),
+                invalidFields = Ext.Array.filter(me.query('[isFormField]'), function(field) {
+                    return field.hasActiveError();
+                }),
+                newErrors = me.getCombinedErrors(invalidFields);
+
+            if (newErrors) {
+                me.setActiveErrors(newErrors);
+            } else {
+                me.unsetActiveError();
+            }
+
+            if (oldError !== me.getActiveError()) {
+                me.doComponentLayout();
+            }
+        }
+    },
+
+    
+    getCombinedErrors: function(invalidFields) {
+        var errors = [],
+            f,
+            fLen   = invalidFields.length,
+            field,
+            activeErrors, a, aLen,
+            error, label;
+
+        for (f = 0; f < fLen; f++) {
+            field = invalidFields[f];
+            activeErrors = field.getActiveErrors();
+            aLen         = activeErrors.length;
+
+            for (a = 0; a < aLen; a++) {
+                error = activeErrors[a];
+                label = field.getFieldLabel();
+
+                errors.push((label ? label + ': ' : '') + error);
+            }
+        }
+
+        return errors;
+    },
+
+    getTargetEl: function() {
+        return this.bodyEl || this.callParent();
+    }
+});
+
+
+Ext.define('Ext.form.CheckboxGroup', {
+    extend:'Ext.form.FieldContainer',
+    mixins: {
+        field: 'Ext.form.field.Field'
+    },
+    alias: 'widget.checkboxgroup',
+    requires: ['Ext.layout.container.CheckboxGroup', 'Ext.form.field.Base'],
+
+    
+
+    
+
+    
+    columns : 'auto',
+
+    
+    vertical : false,
+
+    
+    allowBlank : true,
+
+    
+    
+    blankText : "You must select at least one item in this group",
+    
+
+    
+    defaultType : 'checkboxfield',
+
+    
+    groupCls : Ext.baseCSSPrefix + 'form-check-group',
+
+    
+    fieldBodyCls: Ext.baseCSSPrefix + 'form-checkboxgroup-body',
+
+    
+    layout: 'checkboxgroup',
+
+    initComponent: function() {
+        var me = this;
+        me.callParent();
+        me.initField();
+    },
+
+    
+    initValue: function() {
+        var me = this,
+            valueCfg = me.value;
+        me.originalValue = me.lastValue = valueCfg || me.getValue();
+        if (valueCfg) {
+            me.setValue(valueCfg);
+        }
+    },
+
+    
+    onFieldAdded: function(field) {
+        var me = this;
+        if (field.isCheckbox) {
+            me.mon(field, 'change', me.checkChange, me);
+        }
+        me.callParent(arguments);
+    },
+
+    onFieldRemoved: function(field) {
+        var me = this;
+        if (field.isCheckbox) {
+            me.mun(field, 'change', me.checkChange, me);
+        }
+        me.callParent(arguments);
+    },
+
+    
+    isEqual: function(value1, value2) {
+        var toQueryString = Ext.Object.toQueryString;
+        return toQueryString(value1) === toQueryString(value2);
+    },
+
+    
+    getErrors: function() {
+        var errors = [];
+        if (!this.allowBlank && Ext.isEmpty(this.getChecked())) {
+            errors.push(this.blankText);
+        }
+        return errors;
+    },
+
+    
+    getBoxes: function(query) {
+        return this.query('[isCheckbox]' + (query||''));
+    },
+
+    
+    eachBox: function(fn, scope) {
+        Ext.Array.forEach(this.getBoxes(), fn, scope || this);
+    },
+
+    
+    getChecked: function() {
+        return this.getBoxes('[checked]');
+    },
+
+    
+    isDirty: function(){
+        var boxes = this.getBoxes(),
+            b ,
+            bLen  = boxes.length;
+
+        for (b = 0; b < bLen; b++) {
+            if (boxes[b].isDirty()) {
+                return true;
+            }
+        }
+    },
+
+    
+    setReadOnly: function(readOnly) {
+        var boxes = this.getBoxes(),
+            b,
+            bLen  = boxes.length;
+
+        for (b = 0; b < bLen; b++) {
+            boxes[b].setReadOnly(readOnly);
+        }
+
+        this.readOnly = readOnly;
+    },
+
+    
+    reset: function() {
+        var me = this,
+            hadError = me.hasActiveError(),
+            preventMark = me.preventMark;
+        me.preventMark = true;
+        me.batchChanges(function() {
+            var boxes = me.getBoxes(),
+                b,
+                bLen  = boxes.length;
+
+            for (b = 0; b < bLen; b++) {
+                boxes[b].reset();
+            }
+        });
+        me.preventMark = preventMark;
+        me.unsetActiveError();
+        if (hadError) {
+            me.updateLayout();
+        }
+    },
+
+    resetOriginalValue: function(){
+        var me    = this,
+            boxes = me.getBoxes(),
+            b,
+            bLen  = boxes.length;
+
+        for (b = 0; b < bLen; b++) {
+            boxes[b].resetOriginalValue();
+        }
+
+        me.originalValue = me.getValue();
+        me.checkDirty();
+    },
+
+
+    
+    setValue: function(value) {
+        var me    = this,
+            boxes = me.getBoxes(),
+            b,
+            bLen  = boxes.length,
+            box, name,
+            cbValue;
+
+        me.batchChanges(function() {
+            for (b = 0; b < bLen; b++) {
+                box = boxes[b];
+                name = box.getName();
+                cbValue = false;
+
+                if (value && value.hasOwnProperty(name)) {
+                    if (Ext.isArray(value[name])) {
+                        cbValue = Ext.Array.contains(value[name], box.inputValue);
+                    } else {
+                        
+                        cbValue = value[name];
+                    }
+                }
+
+                box.setValue(cbValue);
+            }
+        });
+        return me;
+    },
+
+
+    
+    getValue: function() {
+        var values = {},
+            boxes  = this.getBoxes(),
+            b,
+            bLen   = boxes.length,
+            box, name, inputValue, bucket;
+
+        for (b = 0; b < bLen; b++) {
+            box        = boxes[b];
+            name       = box.getName();
+            inputValue = box.inputValue;
+
+            if (box.getValue()) {
+                if (values.hasOwnProperty(name)) {
+                    bucket = values[name];
+                    if (!Ext.isArray(bucket)) {
+                        bucket = values[name] = [bucket];
+                    }
+                    bucket.push(inputValue);
+                } else {
+                    values[name] = inputValue;
+                }
+            }
+        }
+
+        return values;
+    },
+
+    
+    getSubmitData: function() {
+        return null;
+    },
+
+    
+    getModelData: function() {
+        return null;
+    },
+
+    validate: function() {
+        var me = this,
+            errors,
+            isValid,
+            wasValid;
+
+        if (me.disabled) {
+            isValid = true;
+        } else {
+            errors = me.getErrors();
+            isValid = Ext.isEmpty(errors);
+            wasValid = !me.hasActiveError();
+            if (isValid) {
+                me.unsetActiveError();
+            } else {
+                me.setActiveError(errors);
+            }
+        }
+        if (isValid !== wasValid) {
+            me.fireEvent('validitychange', me, isValid);
+            me.updateLayout();
+        }
+
+        return isValid;
+    }
+
+}, function() {
+
+    this.borrow(Ext.form.field.Base, ['markInvalid', 'clearInvalid']);
+
+});
+
+
+
+Ext.define('Ext.form.CheckboxManager', {
+    extend: 'Ext.util.MixedCollection',
+    singleton: true,
+
+    getByName: function(name) {
+        return this.filterBy(function(item) {
+            return item.name == name;
+        });
+    },
+
+    getWithValue: function(name, value) {
+        return this.filterBy(function(item) {
+            return item.name == name && item.inputValue == value;
+        });
+    },
+
+    getChecked: function(name) {
+        return this.filterBy(function(item) {
+            return item.name == name && item.checked;
+        });
+    }
+});
+
+
+Ext.define('Ext.layout.component.FieldSet', {
+    extend: 'Ext.layout.component.Body',
+    alias: ['layout.fieldset'],
+
+    type: 'fieldset',
+
+    beforeLayoutCycle: function (ownerContext) {
+        if (ownerContext.target.collapsed) {
+            ownerContext.heightModel = this.sizeModels.shrinkWrap;
+        }
+    },
+
+    beginLayoutCycle: function (ownerContext) {
+        var target = ownerContext.target,
+            lastSize;
+
+        this.callParent(arguments);
+
+        
+        
+        
+        if (target.collapsed) {
+            ownerContext.setContentHeight(0);
+
+            
+            
+            
+            if (ownerContext.widthModel.shrinkWrap) {
+                lastSize = target.lastComponentSize;
+                ownerContext.setContentWidth((lastSize && lastSize.contentWidth) || 100);
+            }
+        }
+    },
+
+    calculateOwnerHeightFromContentHeight: function (ownerContext, contentHeight) {
+        var border = ownerContext.getBorderInfo(),
+            legend = ownerContext.target.legend;
+            
+        
+        return ownerContext.getProp('contentHeight') + ownerContext.getPaddingInfo().height + (legend ? legend.getHeight() : border.top) + border.bottom;
+    },
+
+    publishInnerHeight: function (ownerContext, height) {
+        
+        
+        
+        var legend = ownerContext.target.legend;
+        if (legend) {
+            height -= legend.getHeight();
+        }
+        this.callParent([ownerContext, height]);
+    },
+
+    getLayoutItems : function() {
+        var legend = this.owner.legend;
+        if (legend) {
+            return [legend];
+        }
+        return [];
+    }
+});
+
+
+Ext.define('Ext.form.FieldSet', {
+    extend: 'Ext.container.Container',
+    alias: 'widget.fieldset',
+    uses: ['Ext.form.field.Checkbox', 'Ext.panel.Tool', 'Ext.layout.container.Anchor', 'Ext.layout.component.FieldSet'],
+
+    
+
+    
+
+    
+
+    
+
+    
+    collapsed: false,
+
+    
+    toggleOnTitleClick : true,
+
+    
+
+    
+    baseCls: Ext.baseCSSPrefix + 'fieldset',
+
+    
+    layout: 'anchor',
+
+    border: 1,
+
+    componentLayout: 'fieldset',
+
+    autoEl: 'fieldset',
+
+    childEls: [
+        'body'
+    ],
+
+    renderTpl: [
+        '{%this.renderLegend(out,values);%}',
+        '<div id="{id}-body" class="{baseCls}-body">',
+            '{%this.renderContainer(out,values);%}',
+        '</div>'
+    ],
+
+    stateEvents : [ 'collapse', 'expand' ],
+
+    maskOnDisable: false,
+
+    beforeDestroy: function(){
+        var me = this,
+            legend = me.legend;
+
+        if (legend) {
+            
+            delete legend.ownerCt;
+            legend.destroy();
+            me.legend = null;
+        }
+        me.callParent();
+    },
+
+    initComponent: function() {
+        var me = this,
+            baseCls = me.baseCls;
+
+        me.callParent();
+
+        me.addEvents(
+
+            
+            "beforeexpand",
+
+            
+            "beforecollapse",
+
+            
+            "expand",
+
+            
+            "collapse"
+        );
+
+        if (me.collapsed) {
+            me.addCls(baseCls + '-collapsed');
+            me.collapse();
+        }
+        if (me.title) {
+            me.addCls(baseCls + '-with-title');
+        }
+        if (me.title || me.checkboxToggle || me.collapsible) {
+            me.addCls(baseCls + '-with-legend');
+            me.legend = Ext.widget(me.createLegendCt());
+        }
+    },
+
+    
+    initRenderData: function() {
+        var data = this.callParent();
+
+        data.baseCls = this.baseCls;
+
+        return data;
+    },
+
+    getState: function () {
+        var state = this.callParent();
+
+        state = this.addPropertyToState(state, 'collapsed');
+
+        return state;
+    },
+
+    afterCollapse: Ext.emptyFn,
+    afterExpand: Ext.emptyFn,
+
+    collapsedHorizontal: function () {
+        return true;
+    },
+
+    collapsedVertical: function () {
+        return true;
+    },
+
+    createLegendCt: function () {
+        var me = this,
+            items = [],
+            legend = {
+                xtype: 'container',
+                baseCls: me.baseCls + '-header',
+                id: me.id + '-legend',
+                autoEl: 'legend',
+                items: items,
+                ownerCt: me,
+                ownerLayout: me.componentLayout
+            };
+
+        
+        if (me.checkboxToggle) {
+            items.push(me.createCheckboxCmp());
+        } else if (me.collapsible) {
+            
+            items.push(me.createToggleCmp());
+        }
+
+        
+        items.push(me.createTitleCmp());
+
+        return legend;
+    },
+
+    
+    createTitleCmp: function() {
+        var me  = this,
+            cfg = {
+                xtype : 'component',
+                html  : me.title,
+                cls   : me.baseCls + '-header-text',
+                id    : me.id + '-legendTitle'
+            };
+
+        if (me.collapsible && me.toggleOnTitleClick) {
+            cfg.listeners = {
+                el : {
+                    scope : me,
+                    click : me.toggle
+                }
+            };
+            cfg.cls += ' ' + me.baseCls + '-header-text-collapsible';
+        }
+
+        return (me.titleCmp = Ext.widget(cfg));
+    },
+
+    
+
+    
+    createCheckboxCmp: function() {
+        var me = this,
+            suffix = '-checkbox';
+
+        me.checkboxCmp = Ext.widget({
+            xtype: 'checkbox',
+            hideEmptyLabel: true,
+            name: me.checkboxName || me.id + suffix,
+            cls: me.baseCls + '-header' + suffix,
+            id: me.id + '-legendChk',
+            checked: !me.collapsed,
+            listeners: {
+                change: me.onCheckChange,
+                scope: me
+            }
+        });
+        return me.checkboxCmp;
+    },
+
+    
+
+    
+    createToggleCmp: function() {
+        var me = this;
+        me.toggleCmp = Ext.widget({
+            xtype: 'tool',
+            type: 'toggle',
+            handler: me.toggle,
+            id: me.id + '-legendToggle',
+            scope: me
+        });
+        return me.toggleCmp;
+    },
+
+    doRenderLegend: function (out, renderData) {
+        
+        
+
+        var me = renderData.$comp,
+            legend = me.legend,
+            tree;
+            
+        
+        if (legend) {
+            legend.ownerLayout.configureItem(legend);
+            tree = legend.getRenderTree();
+            Ext.DomHelper.generateMarkup(tree, out);
+        }
+    },
+
+    finishRender: function () {
+        var legend = this.legend;
+
+        this.callParent();
+
+        if (legend) {
+            legend.finishRender();
+        }
+    },
+
+    getCollapsed: function () {
+        return this.collapsed ? 'top' : false;
+    },
+
+    getCollapsedDockedItems: function () {
+        var legend = this.legend;
+
+        return legend ? [ legend ] : [];
+    },
+
+    
+    setTitle: function(title) {
+        var me = this,
+            legend = me.legend;
+            
+        me.title = title;
+        if (me.rendered) {
+            if (!me.legend) {
+                me.legend = legend = Ext.widget(me.createLegendCt());
+                legend.ownerLayout.configureItem(legend);
+                legend.render(me.el, 0);
+            }
+            me.titleCmp.update(title);
+        }
+        return me;
+    },
+
+    getTargetEl : function() {
+        return this.body || this.frameBody || this.el;
+    },
+
+    getContentTarget: function() {
+        return this.body;
+    },
+
+    
+    expand : function(){
+        return this.setExpanded(true);
+    },
+
+    
+    collapse : function() {
+        return this.setExpanded(false);
+    },
+
+    
+    setExpanded: function(expanded) {
+        var me = this,
+            checkboxCmp = me.checkboxCmp,
+            operation = expanded ? 'expand' : 'collapse';
+
+        if (!me.rendered || me.fireEvent('before' + operation, me) !== false) {
+            expanded = !!expanded;
+
+            if (checkboxCmp) {
+                checkboxCmp.setValue(expanded);
+            }
+
+            if (expanded) {
+                me.removeCls(me.baseCls + '-collapsed');
+            } else {
+                me.addCls(me.baseCls + '-collapsed');
+            }
+            me.collapsed = !expanded;
+            if (me.rendered) {
+                
+                
+                
+                me.updateLayout({ isRoot: false });
+                me.fireEvent(operation, me);
+            }
+        }
+        return me;
+    },
+    
+    getRefItems: function(deep) {
+        var refItems = this.callParent(arguments),
+            legend = this.legend;
+
+        
+        if (legend) {
+            refItems.unshift(legend);
+            if (deep) {
+                refItems.unshift.apply(refItems, legend.getRefItems(true));
+            }
+        }
+        return refItems;
+    },
+
+    
+    toggle: function() {
+        this.setExpanded(!!this.collapsed);
+    },
+
+    
+    onCheckChange: function(cmp, checked) {
+        this.setExpanded(checked);
+    },
+
+    setupRenderTpl: function (renderTpl) {
+        this.callParent(arguments);
+
+        renderTpl.renderLegend = this.doRenderLegend;
+    }
+});
+
+
+Ext.define('Ext.form.Label', {
+    extend:'Ext.Component',
+    alias: 'widget.label',
+    requires: ['Ext.util.Format'],
+
+    autoEl: 'label',
+
+    
+    
+    
+    
+    maskOnDisable: false,
+
+    getElConfig: function(){
+        var me = this;
+
+        me.html = me.text ? Ext.util.Format.htmlEncode(me.text) : (me.html || '');
+        return Ext.apply(me.callParent(), {
+            htmlFor: me.forId || ''
+        });
+    },
+
+    
+    setText : function(text, encode){
+        var me = this;
+        
+        encode = encode !== false;
+        if(encode) {
+            me.text = text;
+            delete me.html;
+        } else {
+            me.html = text;
+            delete me.text;
+        }
+        
+        if(me.rendered){
+            me.el.dom.innerHTML = encode !== false ? Ext.util.Format.htmlEncode(text) : text;
+            me.updateLayout();
+        }
+        return me;
+    }
+});
+
+
+
+Ext.define('Ext.form.Panel', {
+    extend:'Ext.panel.Panel',
+    mixins: {
+        fieldAncestor: 'Ext.form.FieldAncestor'
+    },
+    alias: 'widget.form',
+    alternateClassName: ['Ext.FormPanel', 'Ext.form.FormPanel'],
+    requires: ['Ext.form.Basic', 'Ext.util.TaskRunner'],
+
+    
+
+    
+
+    
+    layout: 'anchor',
+
+    ariaRole: 'form',
+    
+    basicFormConfigs: [
+        'api', 
+        'baseParams', 
+        'errorReader', 
+        'method', 
+        'paramOrder',
+        'paramsAsHash',
+        'reader',
+        'standardSubmit',
+        'timeout',
+        'trackResetOnLoad',
+        'url',
+        'waitMsgTarget',
+        'waitTitle'
+    ],
+
+    initComponent: function() {
+        var me = this;
+
+        if (me.frame) {
+            me.border = false;
+        }
+
+        me.initFieldAncestor();
+        me.callParent();
+
+        me.relayEvents(me.form, [
+            
+            'beforeaction',
+            
+            'actionfailed',
+            
+            'actioncomplete',
+            
+            'validitychange',
+            
+            'dirtychange'
+        ]);
+
+        
+        if (me.pollForChanges) {
+            me.startPolling(me.pollInterval || 500);
+        }
+    },
+
+    initItems: function() {
+        
+        var me = this;
+
+        me.form = me.createForm();
+        me.callParent();
+    },
+
+    
+    afterFirstLayout: function() {
+        this.callParent();
+        this.form.initialize();
+    },
+
+    
+    createForm: function() {
+        var cfg = {},
+            props = this.basicFormConfigs,
+            len = props.length,
+            i = 0,
+            prop;
+            
+        for (; i < len; ++i) {
+            prop = props[i];
+            cfg[prop] = this[prop];
+        }
+        return new Ext.form.Basic(this, cfg);
+    },
+
+    
+    getForm: function() {
+        return this.form;
+    },
+
+    
+    loadRecord: function(record) {
+        return this.getForm().loadRecord(record);
+    },
+
+    
+    getRecord: function() {
+        return this.getForm().getRecord();
+    },
+
+    
+    getValues: function(asString, dirtyOnly, includeEmptyText, useDataValues) {
+        return this.getForm().getValues(asString, dirtyOnly, includeEmptyText, useDataValues);
+    },
+
+    beforeDestroy: function() {
+        this.stopPolling();
+        this.form.destroy();
+        this.callParent();
+    },
+
+    
+    load: function(options) {
+        this.form.load(options);
+    },
+
+    
+    submit: function(options) {
+        this.form.submit(options);
+    },
+
+    
+    startPolling: function(interval) {
+        this.stopPolling();
+        var task = new Ext.util.TaskRunner(interval);
+        task.start({
+            interval: 0,
+            run: this.checkChange,
+            scope: this
+        });
+        this.pollTask = task;
+    },
+
+    
+    stopPolling: function() {
+        var task = this.pollTask;
+        if (task) {
+            task.stopAll();
+            delete this.pollTask;
+        }
+    },
+
+    
+    checkChange: function() {
+        var fields = this.form.getFields().items,
+            f,
+            fLen   = fields.length,
+            field;
+
+        for (f = 0; f < fLen; f++) {
+            fields[f].checkChange();
+        }
+    }
+});
+
+
+Ext.define('Ext.form.RadioGroup', {
+    extend: 'Ext.form.CheckboxGroup',
+    alias: 'widget.radiogroup',
+
+    
+    
+    allowBlank : true,
+    
+    
+    blankText : 'You must select one item in this group',
+    
+
+    
+    defaultType : 'radiofield',
+
+    
+    groupCls : Ext.baseCSSPrefix + 'form-radio-group',
+
+    getBoxes: function(query) {
+        return this.query('[isRadio]' + (query||''));
+    },
+    
+    checkChange: function() {
+        var value = this.getValue(),
+            key = Ext.Object.getKeys(value)[0];
+            
+        
+        
+        if (Ext.isArray(value[key])) {
+            return;
+        }
+        this.callParent(arguments);    
+    },
+
+    
+    setValue: function(value) {
+        var cbValue, first, formId, radios,
+            i, len, name;
+
+        if (Ext.isObject(value)) {
+            for (name in value) {
+                if (value.hasOwnProperty(name)) {
+                    cbValue = value[name];
+                    first = this.items.first();
+                    formId = first ? first.getFormId() : null;
+                    radios = Ext.form.RadioManager.getWithValue(name, cbValue, formId).items;
+                    len = radios.length;
+
+                    for (i = 0; i < len; ++i) {
+                        radios[i].setValue(true);
+                    }
+                }
+            }
+        }
+        return this;
+    }
+});
+
+
+Ext.define('Ext.form.RadioManager', {
+    extend: 'Ext.util.MixedCollection',
+    singleton: true,
+
+    getByName: function(name, formId) {
+        return this.filterBy(function(item) {
+            return item.name == name && item.getFormId() == formId;
+        });
+    },
+
+    getWithValue: function(name, value, formId) {
+        return this.filterBy(function(item) {
+            return item.name == name && item.inputValue == value && item.getFormId() == formId;
+        });
+    },
+
+    getChecked: function(name, formId) {
+        return this.findBy(function(item) {
+            return item.name == name && item.checked && item.getFormId() == formId;
+        });
+    }
+});
+
+
+Ext.define('Ext.form.action.DirectLoad', {
+    extend:'Ext.form.action.Load',
+    requires: ['Ext.direct.Manager'],
+    alternateClassName: 'Ext.form.Action.DirectLoad',
+    alias: 'formaction.directload',
+
+    type: 'directload',
+
+    run: function() {
+        var me = this,
+            form = me.form,
+            fn = form.api.load,
+            method = fn.directCfg.method,
+            args = method.getArgs(me.getParams(), form.paramOrder, form.paramsAsHash);
+            
+        args.push(me.onComplete, me);
+        fn.apply(window, args);
+    },
+
+    
+    
+    
+    processResponse: function(result) {
+        return (this.result = result);
+    },
+
+    onComplete: function(data, response) {
+        if (data) {
+            this.onSuccess(data);
+        } else {
+            this.onFailure(null);
+        }
+    }
+});
+
+
+
+
+Ext.define('Ext.form.action.DirectSubmit', {
+    extend:'Ext.form.action.Submit',
+    requires: ['Ext.direct.Manager'],
+    alternateClassName: 'Ext.form.Action.DirectSubmit',
+    alias: 'formaction.directsubmit',
+
+    type: 'directsubmit',
+
+    doSubmit: function() {
+        var me = this,
+            callback = Ext.Function.bind(me.onComplete, me),
+            formEl = me.buildForm();
+        me.form.api.submit(formEl, callback, me);
+        Ext.removeNode(formEl);
+    },
+
+    
+    
+    
+    processResponse: function(result) {
+        return (this.result = result);
+    },
+    
+    onComplete: function(data, response){
+        if (data) {
+            this.onSuccess(data);
+        } else {
+            this.onFailure(null);
+        }
+    }
+});
+
+
+Ext.define('Ext.form.action.StandardSubmit', {
+    extend:'Ext.form.action.Submit',
+    alias: 'formaction.standardsubmit',
+
+    
+
+    
+    doSubmit: function() {
+        var form = this.buildForm();
+        form.submit();
+        Ext.removeNode(form);
+    }
+
+});
+
+
+Ext.define('Ext.form.field.Checkbox', {
+    extend: 'Ext.form.field.Base',
+    alias: ['widget.checkboxfield', 'widget.checkbox'],
+    alternateClassName: 'Ext.form.Checkbox',
+    requires: ['Ext.XTemplate', 'Ext.form.CheckboxManager' ],
+
+    componentLayout: 'field',
+
+    childEls: [
+        
+        'boxLabelEl'
+    ],
+
+    
+    fieldSubTpl: [
+        '<tpl if="boxLabel && boxLabelAlign == \'before\'">',
+            '{beforeBoxLabelTpl}',
+            '<label id="{cmpId}-boxLabelEl" {boxLabelAttrTpl} class="{boxLabelCls} {boxLabelCls}-{boxLabelAlign}" for="{id}">',
+                '{beforeBoxLabelTextTpl}',
+                '{boxLabel}',
+                '{afterBoxLabelTextTpl}',
+            '</label>',
+            '{afterBoxLabelTpl}',
+        '</tpl>',
+        
+        
+        
+        '<input type="button" id="{id}" {inputAttrTpl}',
+            '<tpl if="tabIdx"> tabIndex="{tabIdx}"</tpl>',
+            '<tpl if="disabled"> disabled="disabled"</tpl>',
+            '<tpl if="fieldStyle"> style="{fieldStyle}"</tpl>',
+            ' class="{fieldCls} {typeCls}" autocomplete="off" hidefocus="true" />',
+        '<tpl if="boxLabel && boxLabelAlign == \'after\'">',
+            '{beforeBoxLabelTpl}',
+            '<label id="{cmpId}-boxLabelEl" {boxLabelAttrTpl} class="{boxLabelCls} {boxLabelCls}-{boxLabelAlign}" for="{id}">',
+                '{beforeBoxLabelTextTpl}',
+                '{boxLabel}',
+                '{afterBoxLabelTextTpl}',
+            '</label>',
+            '{afterBoxLabelTpl}',
+        '</tpl>',
+        {
+            disableFormats: true,
+            compiled: true
+        }
+    ],
+
+    subTplInsertions: [
+        
+        'beforeBoxLabelTpl',
+
+        
+        'afterBoxLabelTpl',
+
+        
+        'beforeBoxLabelTextTpl',
+
+        
+        'afterBoxLabelTextTpl',
+
+        
+        'boxLabelAttrTpl',
+
+        
+        'inputAttrTpl'
+    ],
+
+    
+    isCheckbox: true,
+
+    
+    focusCls: 'form-cb-focus',
+
+    
+
+    
+    fieldBodyCls: Ext.baseCSSPrefix + 'form-cb-wrap',
+
+    
+    checked: false,
+
+    
+    checkedCls: Ext.baseCSSPrefix + 'form-cb-checked',
+
+    
+
+    
+    boxLabelCls: Ext.baseCSSPrefix + 'form-cb-label',
+
+    
+    boxLabelAlign: 'after',
+
+    
+    inputValue: 'on',
+
+    
+
+    
+
+    
+
+    
+    checkChangeEvents: [],
+    inputType: 'checkbox',
+
+    
+    onRe: /^on$/i,
+
+    initComponent: function() {
+        this.callParent(arguments);
+        this.getManager().add(this);
+    },
+
+    initValue: function() {
+        var me = this,
+            checked = !!me.checked;
+
+        
+        me.originalValue = me.lastValue = checked;
+
+        
+        me.setValue(checked);
+    },
+
+    getElConfig: function() {
+        var me = this;
+
+        
+        if (me.isChecked(me.rawValue, me.inputValue)) {
+            me.addCls(me.checkedCls);
+        }
+        return me.callParent();
+    },
+
+    getFieldStyle: function() {
+        return Ext.isObject(this.fieldStyle) ? Ext.DomHelper.generateStyles(this.fieldStyle) : this.fieldStyle ||'';
+    },
+
+    getSubTplData: function() {
+        var me = this;
+        return Ext.apply(me.callParent(), {
+            disabled      : me.readOnly || me.disabled,
+            boxLabel      : me.boxLabel,
+            boxLabelCls   : me.boxLabelCls,
+            boxLabelAlign : me.boxLabelAlign
+        });
+    },
+
+    initEvents: function() {
+        var me = this;
+        me.callParent();
+        me.mon(me.inputEl, 'click', me.onBoxClick, me);
+    },
+
+    
+    onBoxClick: function(e) {
+        var me = this;
+        if (!me.disabled && !me.readOnly) {
+            this.setValue(!this.checked);
+        }
+    },
+
+    
+    getRawValue: function() {
+        return this.checked;
+    },
+
+    
+    getValue: function() {
+        return this.checked;
+    },
+
+    
+    getSubmitValue: function() {
+        var unchecked = this.uncheckedValue,
+            uncheckedVal = Ext.isDefined(unchecked) ? unchecked : null;
+        return this.checked ? this.inputValue : uncheckedVal;
+    },
+
+    isChecked: function(rawValue, inputValue) {
+        return (rawValue === true || rawValue === 'true' || rawValue === '1' || rawValue === 1 ||
+                      (((Ext.isString(rawValue) || Ext.isNumber(rawValue)) && inputValue) ? rawValue == inputValue : this.onRe.test(rawValue)));
+    },
+
+    
+    setRawValue: function(value) {
+        var me = this,
+            inputEl = me.inputEl,
+            checked = me.isChecked(value, me.inputValue);
+
+        if (inputEl) {
+            me[checked ? 'addCls' : 'removeCls'](me.checkedCls);
+        }
+
+        me.checked = me.rawValue = checked;
+        return checked;
+    },
+
+    
+    setValue: function(checked) {
+        var me = this,
+            boxes, i, len, box;
+
+        
+        
+        
+        
+        if (Ext.isArray(checked)) {
+            boxes = me.getManager().getByName(me.name, me.getFormId()).items;
+            len = boxes.length;
+
+            for (i = 0; i < len; ++i) {
+                box = boxes[i];
+                box.setValue(Ext.Array.contains(checked, box.inputValue));
+            }
+        } else {
+            me.callParent(arguments);
+        }
+
+        return me;
+    },
+
+    
+    valueToRaw: function(value) {
+        
+        return value;
+    },
+
+    
+    onChange: function(newVal, oldVal) {
+        var me = this,
+            handler = me.handler;
+        if (handler) {
+            handler.call(me.scope || me, me, newVal);
+        }
+        me.callParent(arguments);
+    },
+    
+    resetOriginalValue: function( fromBoxInGroup){
+        var me = this,
+            boxes,
+            box,
+            len,
+            i;
+            
+        
+        if (!fromBoxInGroup) {
+            boxes = me.getManager().getByName(me.name, me.getFormId()).items;
+            len  = boxes.length;
+            
+            for (i = 0; i < len; ++i) {
+                box = boxes[i];
+                if (box !== me) {
+                    boxes[i].resetOriginalValue(true);
+                }
+            }
+        }
+        me.callParent();
+    },
+
+    
+    beforeDestroy: function(){
+        this.callParent();
+        this.getManager().removeAtKey(this.id);
+    },
+
+    
+    getManager: function() {
+        return Ext.form.CheckboxManager;
+    },
+
+    onEnable: function() {
+        var me = this,
+            inputEl = me.inputEl;
+        me.callParent();
+        if (inputEl) {
+            
+            inputEl.dom.disabled = me.readOnly;
+        }
+    },
+
+    setReadOnly: function(readOnly) {
+        var me = this,
+            inputEl = me.inputEl;
+        if (inputEl) {
+            
+            inputEl.dom.disabled = !!readOnly || me.disabled;
+        }
+        me.callParent(arguments);
+    },
+
+    getFormId: function(){
+        var me = this,
+            form;
+
+        if (!me.formId) {
+            form = me.up('form');
+            if (form) {
+                me.formId = form.id;
+            }
+        }
+        return me.formId;
+    }
+});
+
+
+Ext.define('Ext.layout.component.field.Trigger', {
+
+    
+
+    alias: 'layout.triggerfield',
+
+    extend: 'Ext.layout.component.field.Field',
+
+    
+
+    type: 'triggerfield',
+
+    beginLayout: function(ownerContext) {
+        var me = this,
+            owner = me.owner,
+            flags;
+
+        ownerContext.triggerWrap = ownerContext.getEl('triggerWrap');
+
+        me.callParent(arguments);
+
+        
+        flags = owner.getTriggerStateFlags();
+        if (flags != owner.lastTriggerStateFlags) {
+            owner.lastTriggerStateFlags = flags;
+            me.updateEditState();
+        }
+    },
+
+    beginLayoutFixed: function (ownerContext, width, suffix) {
+        var me = this,
+            owner = ownerContext.target,
+            ieInputWidthAdjustment = me.ieInputWidthAdjustment || 0,
+            inputWidth = '100%',
+            triggerWrap = owner.triggerWrap;
+
+        me.callParent(arguments);
+
+        owner.inputCell.setStyle('width', '100%');
+        if(ieInputWidthAdjustment) {
+            
+            
+            owner.inputCell.setStyle('padding-right', ieInputWidthAdjustment + 'px');
+            if(suffix === 'px') {
+                if (owner.inputWidth) {
+                    inputWidth = owner.inputWidth - owner.getTriggerWidth();
+                } else {
+                    inputWidth = width - ieInputWidthAdjustment - owner.getTriggerWidth();
+                }
+                inputWidth += 'px';
+            }
+        }
+        owner.inputEl.setStyle('width', inputWidth);
+        inputWidth = owner.inputWidth;
+        if (inputWidth) {
+            triggerWrap.setStyle('width', inputWidth + (ieInputWidthAdjustment) + 'px');
+        } else {
+            triggerWrap.setStyle('width', width + suffix);
+        }
+        triggerWrap.setStyle('table-layout', 'fixed');
+    },
+
+    beginLayoutShrinkWrap: function (ownerContext) {
+        var owner = ownerContext.target,
+            emptyString = '',
+            inputWidth = owner.inputWidth,
+            triggerWrap = owner.triggerWrap,
+            ieInputWidthAdjustment = this.ieInputWidthAdjustment || 0;
+
+        this.callParent(arguments);
+
+        if (inputWidth) {
+            triggerWrap.setStyle('width', inputWidth + 'px');
+            inputWidth = (inputWidth - owner.getTriggerWidth()) + 'px';
+            owner.inputEl.setStyle('width', inputWidth);
+            owner.inputCell.setStyle('width', inputWidth);
+        } else {
+            owner.inputCell.setStyle('width', emptyString);
+            owner.inputEl.setStyle('width', emptyString);
+            triggerWrap.setStyle('width', emptyString);
+            triggerWrap.setStyle('table-layout', 'auto');
+        }
+    },
+
+    getTextWidth: function () {
+        var me = this,
+            owner = me.owner,
+            inputEl = owner.inputEl,
+            value;
+
+        
+        value = (inputEl.dom.value || (owner.hasFocus ? '' : owner.emptyText) || '') + owner.growAppend;
+        return inputEl.getTextWidth(value);
+    },
+
+    measureContentWidth: function (ownerContext) {
+        var me = this,
+            owner = me.owner,
+            width = me.callParent(arguments),
+            inputContext = ownerContext.inputContext,
+            calcWidth, max, min;
+
+        if (owner.grow && !ownerContext.state.growHandled) {
+            calcWidth = me.getTextWidth() + ownerContext.inputContext.getFrameInfo().width;
+
+            max = owner.growMax;
+            min = Math.min(max, width);
+            max = Math.max(owner.growMin, max, min);
+
+            
+            calcWidth = Ext.Number.constrain(calcWidth, owner.growMin, max);
+            inputContext.setWidth(calcWidth);
+            ownerContext.state.growHandled = true;
+            
+            
+            inputContext.domBlock(me, 'width');
+            width = NaN;
+        }
+        return width;
+    },
+
+    updateEditState: function() {
+        var me = this,
+            owner = me.owner,
+            inputEl = owner.inputEl,
+            noeditCls = Ext.baseCSSPrefix + 'trigger-noedit',
+            displayed,
+            readOnly;
+
+        if (me.owner.readOnly) {
+            inputEl.addCls(noeditCls);
+            readOnly = true;
+            displayed = false;
+        } else {
+            if (me.owner.editable) {
+                inputEl.removeCls(noeditCls);
+                readOnly = false;
+            } else {
+                inputEl.addCls(noeditCls);
+                readOnly = true;
+            }
+            displayed = !me.owner.hideTrigger;
+        }
+
+        owner.triggerCell.setDisplayed(displayed);
+        inputEl.dom.readOnly = readOnly;
+    }
+});
+
+
+Ext.define('Ext.layout.component.field.ComboBox', {
+    extend: 'Ext.layout.component.field.Trigger',
+    alias: 'layout.combobox',
+    requires: ['Ext.util.TextMetrics'],
+
+    type: 'combobox',
+
+    startingWidth: null,
+
+    getTextWidth: function () {
+        var me = this,
+            owner = me.owner,
+            store = owner.store,
+            field = owner.displayField,
+            storeLn = store.data.length,
+            value = '',
+            i = 0, n = 0, ln, item, width;
+
+        for (; i < storeLn; i++) {
+            item = store.getAt(i).data[field];
+            ln = item.length;
+            
+            if (ln > n) {
+                n = ln;
+                value = item;
+            }
+        }
+
+        width = Math.max(me.callParent(arguments), owner.inputEl.getTextWidth(value + owner.growAppend));
+
+        
+        
+        if (!me.startingWidth || owner.removingRecords) {
+            me.startingWidth = width;
+
+            
+            
+            if (width < owner.growMin) {
+                owner.defaultListConfig.minWidth = owner.growMin;
+            }
+
+            owner.removingRecords = false;
+        }
+ 
+        
+        return (width < me.startingWidth) ? me.startingWidth : width;
+    }
+});
+
+
+Ext.define('Ext.form.field.Trigger', {
+    extend:'Ext.form.field.Text',
+    alias: ['widget.triggerfield', 'widget.trigger'],
+    requires: ['Ext.DomHelper', 'Ext.util.ClickRepeater', 'Ext.layout.component.field.Trigger'],
+    alternateClassName: ['Ext.form.TriggerField', 'Ext.form.TwinTriggerField', 'Ext.form.Trigger'],
+
+    childEls: [
+        
+        { name: 'triggerCell', select: '.' + Ext.baseCSSPrefix + 'trigger-cell' },
+        { name: 'triggerEl', select: '.' + Ext.baseCSSPrefix + 'form-trigger' },
+
+        
+        'triggerWrap',
+
+        
+        'inputCell'
+    ],
+
+    
+
+    
+    triggerBaseCls: Ext.baseCSSPrefix + 'form-trigger',
+
+    
+    triggerWrapCls: Ext.baseCSSPrefix + 'form-trigger-wrap',
+
+    
+    triggerNoEditCls: Ext.baseCSSPrefix + 'trigger-noedit',
+
+    
+    hideTrigger: false,
+
+    
+    editable: true,
+
+    
+    readOnly: false,
+
+    
+
+    
+    repeatTriggerClick: false,
+
+
+    
+    autoSize: Ext.emptyFn,
+    
+    monitorTab: true,
+    
+    mimicing: false,
+    
+    triggerIndexRe: /trigger-index-(\d+)/,
+
+    componentLayout: 'triggerfield',
+
+    initComponent: function() {
+        this.wrapFocusCls = this.triggerWrapCls + '-focus';
+        this.callParent(arguments);
+    },
+
+    getSubTplMarkup: function() {
+        var me = this,
+            field = me.callParent(arguments);
+
+        return '<table id="' + me.id + '-triggerWrap" class="' + Ext.baseCSSPrefix + 'form-trigger-wrap" cellpadding="0" cellspacing="0"><tbody><tr>' +
+            '<td id="' + me.id + '-inputCell" class="' + Ext.baseCSSPrefix + 'form-trigger-input-cell">' + field + '</td>' +
+            me.getTriggerMarkup() +
+            '</tr></tbody></table>';
+    },
+    
+    getSubTplData: function(){
+        var me = this,
+            data = me.callParent(),
+            readOnly = me.readOnly === true,
+            editable = me.editable !== false;
+        
+        return Ext.apply(data, {
+            editableCls: (readOnly || !editable) ? ' ' + me.triggerNoEditCls : '',
+            readOnly: !editable || readOnly
+        });  
+    },
+
+    getLabelableRenderData: function() {
+        var me = this,
+            triggerWrapCls = me.triggerWrapCls,
+            result = me.callParent(arguments);
+
+        return Ext.applyIf(result, {
+            triggerWrapCls: triggerWrapCls,
+            triggerMarkup: me.getTriggerMarkup()
+        });
+    },
+
+    getTriggerMarkup: function() {
+        var me = this,
+            i = 0,
+            hideTrigger = (me.readOnly || me.hideTrigger),
+            triggerCls,
+            triggerBaseCls = me.triggerBaseCls,
+            triggerConfigs = [];
+
+        
+        
+        
+        
+        if (!me.trigger1Cls) {
+            me.trigger1Cls = me.triggerCls;
+        }
+
+        
+        for (i = 0; (triggerCls = me['trigger' + (i + 1) + 'Cls']) || i < 1; i++) {
+            triggerConfigs.push({
+                tag: 'td',
+                valign: 'top',
+                cls: Ext.baseCSSPrefix + 'trigger-cell',
+                style: 'width:' + me.triggerWidth + (hideTrigger ? 'px;display:none' : 'px'),
+                cn: {
+                    cls: [Ext.baseCSSPrefix + 'trigger-index-' + i, triggerBaseCls, triggerCls].join(' '),
+                    role: 'button'
+                }
+            });
+        }
+        triggerConfigs[i - 1].cn.cls += ' ' + triggerBaseCls + '-last';
+
+        return Ext.DomHelper.markup(triggerConfigs);
+    },
+    
+    disableCheck: function() {
+        return !this.disabled;    
+    },
+
+    
+    beforeRender: function() {
+        var me = this,
+            triggerBaseCls = me.triggerBaseCls,
+            tempEl;
+            
+        
+        if (!me.triggerWidth) {
+            tempEl = Ext.resetElement.createChild({
+                style: 'position: absolute;', 
+                cls: Ext.baseCSSPrefix + 'form-trigger'
+            });
+            Ext.form.field.Trigger.prototype.triggerWidth = tempEl.getWidth();
+            tempEl.remove();
+        }
+
+        me.callParent();
+
+        if (triggerBaseCls != Ext.baseCSSPrefix + 'form-trigger') {
+            
+            
+            me.addChildEls({ name: 'triggerEl', select: '.' + triggerBaseCls });
+        }
+
+        
+        me.lastTriggerStateFlags = me.getTriggerStateFlags();
+    },
+
+    onRender: function() {
+        var me = this;
+
+        me.callParent(arguments);
+
+        me.doc = Ext.getDoc();
+        me.initTrigger();
+        me.triggerEl.unselectable();
+    },
+
+    
+    getTriggerWidth: function() {
+        var me = this,
+            totalTriggerWidth = 0;
+
+        if (me.triggerWrap && !me.hideTrigger && !me.readOnly) {
+            totalTriggerWidth = me.triggerEl.getCount() * me.triggerWidth;
+        }
+        return totalTriggerWidth;
+    },
+
+    setHideTrigger: function(hideTrigger) {
+        if (hideTrigger != this.hideTrigger) {
+            this.hideTrigger = hideTrigger;
+            this.updateLayout();
+        }
+    },
+
+    
+    setEditable: function(editable) {
+        if (editable != this.editable) {
+            this.editable = editable;
+            this.updateLayout();
+        }
+    },
+
+    
+    setReadOnly: function(readOnly) {
+        if (readOnly != this.readOnly) {
+            this.readOnly = readOnly;
+            this.updateLayout();
+        }
+    },
+
+    
+    initTrigger: function() {
+        var me = this,
+            triggerWrap = me.triggerWrap,
+            triggerEl = me.triggerEl,
+            disableCheck = me.disableCheck,
+            els, eLen, el, e, idx;
+
+        if (me.repeatTriggerClick) {
+            me.triggerRepeater = new Ext.util.ClickRepeater(triggerWrap, {
+                preventDefault: true,
+                handler: me.onTriggerWrapClick,
+                listeners: {
+                    mouseup: me.onTriggerWrapMouseup,
+                    scope: me
+                },
+                scope: me
+            });
+        } else {
+            me.mon(triggerWrap, {
+                click: me.onTriggerWrapClick,
+                mouseup: me.onTriggerWrapMouseup,
+                scope: me
+            });
+        }
+
+        triggerEl.setVisibilityMode(Ext.Element.DISPLAY);
+        triggerEl.addClsOnOver(me.triggerBaseCls + '-over', disableCheck, me);
+
+        els  = triggerEl.elements;
+        eLen = els.length;
+
+        for (e = 0; e < eLen; e++) {
+            el = els[e];
+            idx = e+1;
+            el.addClsOnOver(me['trigger' + (idx) + 'Cls'] + '-over', disableCheck, me);
+            el.addClsOnClick(me['trigger' + (idx) + 'Cls'] + '-click', disableCheck, me);
+        }
+
+        triggerEl.addClsOnClick(me.triggerBaseCls + '-click', disableCheck, me);
+
+    },
+
+    
+    onDestroy: function() {
+        var me = this;
+        Ext.destroyMembers(me, 'triggerRepeater', 'triggerWrap', 'triggerEl');
+        delete me.doc;
+        me.callParent();
+    },
+
+    
+    onFocus: function() {
+        var me = this;
+        me.callParent(arguments);
+        if (!me.mimicing) {
+            me.bodyEl.addCls(me.wrapFocusCls);
+            me.mimicing = true;
+            me.mon(me.doc, 'mousedown', me.mimicBlur, me, {
+                delay: 10
+            });
+            if (me.monitorTab) {
+                me.on('specialkey', me.checkTab, me);
+            }
+        }
+    },
+
+    
+    checkTab: function(me, e) {
+        if (!this.ignoreMonitorTab && e.getKey() == e.TAB) {
+            this.triggerBlur();
+        }
+    },
+
+    
+    getTriggerStateFlags: function () {
+        var me = this,
+            state = 0;
+
+        if (me.readOnly) {
+            state += 1;
+        }
+        if (me.editable) {
+            state += 2;
+        }
+        if (me.hideTrigger) {
+            state += 4;
+        }
+        return state;
+    },
+
+    
+    onBlur: Ext.emptyFn,
+
+    
+    mimicBlur: function(e) {
+        if (!this.isDestroyed && !this.bodyEl.contains(e.target) && this.validateBlur(e)) {
+            this.triggerBlur(e);
+        }
+    },
+
+    
+    triggerBlur: function(e) {
+        var me = this;
+        me.mimicing = false;
+        me.mun(me.doc, 'mousedown', me.mimicBlur, me);
+        if (me.monitorTab && me.inputEl) {
+            me.un('specialkey', me.checkTab, me);
+        }
+        Ext.form.field.Trigger.superclass.onBlur.call(me, e);
+        if (me.bodyEl) {
+            me.bodyEl.removeCls(me.wrapFocusCls);
+        }
+    },
+
+    
+    
+    validateBlur: function(e) {
+        return true;
+    },
+
+    
+    
+    
+    onTriggerWrapClick: function() {
+        var me = this,
+            targetEl, match,
+            triggerClickMethod,
+            event;
+
+        event = arguments[me.triggerRepeater ? 1 : 0];
+        if (event && !me.readOnly && !me.disabled) {
+                targetEl = event.getTarget('.' + me.triggerBaseCls, null);
+                match = targetEl && targetEl.className.match(me.triggerIndexRe);
+
+            if (match) {
+                triggerClickMethod = me['onTrigger' + (parseInt(match[1], 10) + 1) + 'Click'] || me.onTriggerClick;
+                if (triggerClickMethod) {
+                    triggerClickMethod.call(me, event);
+                }
+            }
+        }
+    },
+
+    
+    
+    
+    onTriggerWrapMouseup: Ext.emptyFn,
+
+    
+    onTriggerClick: Ext.emptyFn
+
+    
+    
+    
+});
+
+
+Ext.define('Ext.form.field.Picker', {
+    extend: 'Ext.form.field.Trigger',
+    alias: 'widget.pickerfield',
+    alternateClassName: 'Ext.form.Picker',
+    requires: ['Ext.util.KeyNav'],
+
+    
+    matchFieldWidth: true,
+
+    
+    pickerAlign: 'tl-bl?',
+
+    
+
+    
+    openCls: Ext.baseCSSPrefix + 'pickerfield-open',
+
+    
+
+    
+    editable: true,
+
+
+    initComponent: function() {
+        this.callParent();
+
+        
+        this.addEvents(
+            
+            'expand',
+            
+            'collapse',
+            
+            'select'
+        );
+    },
+
+
+    initEvents: function() {
+        var me = this;
+        me.callParent();
+
+        
+        me.keyNav = new Ext.util.KeyNav(me.inputEl, {
+            down: me.onDownArrow,
+            esc: {
+                handler: me.onEsc,
+                scope: me,
+                defaultEventAction: false
+            },
+            scope: me,
+            forceKeyDown: true
+        });
+
+        
+        if (!me.editable) {
+            me.mon(me.inputEl, 'click', me.onTriggerClick, me);
+        }
+
+        
+        if (Ext.isGecko) {
+            me.inputEl.dom.setAttribute('autocomplete', 'off');
+        }
+    },
+
+    
+    onEsc: function(e) {
+        var me = this;
+        if (me.isExpanded) {
+            me.collapse();
+            e.stopEvent();
+        } else {
+            
+            
+            if (me.up('window')) {
+                me.blur();
+            }
+            
+            else if ((!Ext.FocusManager || !Ext.FocusManager.enabled)) {
+                e.stopEvent();
+            }
+        }
+    },
+
+    onDownArrow: function(e) {
+        if (!this.isExpanded) {
+            
+            
+            this.onTriggerClick();
+        }
+    },
+
+    
+    expand: function() {
+        var me = this,
+            bodyEl, picker, collapseIf;
+
+        if (me.rendered && !me.isExpanded && !me.isDestroyed) {
+            bodyEl = me.bodyEl;
+            picker = me.getPicker();
+            collapseIf = me.collapseIf;
+
+            
+            picker.show();
+            me.isExpanded = true;
+            me.alignPicker();
+            bodyEl.addCls(me.openCls);
+
+            
+            me.mon(Ext.getDoc(), {
+                mousewheel: collapseIf,
+                mousedown: collapseIf,
+                scope: me
+            });
+            Ext.EventManager.onWindowResize(me.alignPicker, me);
+            me.fireEvent('expand', me);
+            me.onExpand();
+        }
+    },
+
+    onExpand: Ext.emptyFn,
+
+    
+    alignPicker: function() {
+        var me = this,
+            picker = me.getPicker();
+
+        if (me.isExpanded) {
+            if (me.matchFieldWidth) {
+                
+                picker.setWidth(me.bodyEl.getWidth());
+            }
+            if (picker.isFloating()) {
+                me.doAlign();
+            }
+        }
+    },
+
+    
+    doAlign: function(){
+        var me = this,
+            picker = me.picker,
+            aboveSfx = '-above',
+            isAbove;
+
+        me.picker.alignTo(me.inputEl, me.pickerAlign, me.pickerOffset);
+        
+        
+        isAbove = picker.el.getY() < me.inputEl.getY();
+        me.bodyEl[isAbove ? 'addCls' : 'removeCls'](me.openCls + aboveSfx);
+        picker[isAbove ? 'addCls' : 'removeCls'](picker.baseCls + aboveSfx);
+    },
+
+    
+    collapse: function() {
+        if (this.isExpanded && !this.isDestroyed) {
+            var me = this,
+                openCls = me.openCls,
+                picker = me.picker,
+                doc = Ext.getDoc(),
+                collapseIf = me.collapseIf,
+                aboveSfx = '-above';
+
+            
+            picker.hide();
+            me.isExpanded = false;
+
+            
+            me.bodyEl.removeCls([openCls, openCls + aboveSfx]);
+            picker.el.removeCls(picker.baseCls + aboveSfx);
+
+            
+            doc.un('mousewheel', collapseIf, me);
+            doc.un('mousedown', collapseIf, me);
+            Ext.EventManager.removeResizeListener(me.alignPicker, me);
+            me.fireEvent('collapse', me);
+            me.onCollapse();
+        }
+    },
+
+    onCollapse: Ext.emptyFn,
+
+
+    
+    collapseIf: function(e) {
+        var me = this;
+
+        if (!me.isDestroyed && !e.within(me.bodyEl, false, true) && !e.within(me.picker.el, false, true) && !me.isEventWithinPickerLoadMask(e)) {
+            me.collapse();
+        }
+    },
+
+    
+    getPicker: function() {
+        var me = this;
+        return me.picker || (me.picker = me.createPicker());
+    },
+
+    
+    createPicker: Ext.emptyFn,
+
+    
+    onTriggerClick: function() {
+        var me = this;
+        if (!me.readOnly && !me.disabled) {
+            if (me.isExpanded) {
+                me.collapse();
+            } else {
+                me.expand();
+            }
+            me.inputEl.focus();
+        }
+    },
+
+    mimicBlur: function(e) {
+        var me = this,
+            picker = me.picker;
+        
+        if (!picker || !e.within(picker.el, false, true) && !me.isEventWithinPickerLoadMask(e)) {
+            me.callParent(arguments);
+        }
+    },
+
+    onDestroy : function(){
+        var me = this,
+            picker = me.picker;
+
+        Ext.EventManager.removeResizeListener(me.alignPicker, me);
+        Ext.destroy(me.keyNav);
+        if (picker) {
+            delete picker.pickerField;
+            picker.destroy();
+        }
+        me.callParent();
+    },
+
+    
+    isEventWithinPickerLoadMask: function(e) {
+        var loadMask = this.picker.loadMask;
+
+        return loadMask ? e.within(loadMask.maskEl, false, true) || e.within(loadMask.el, false, true) : false;
+    }
+
+});
+
+
+
+Ext.define('Ext.layout.component.BoundList', {
+    extend: 'Ext.layout.component.Auto',
+    alias: 'layout.boundlist',
+
+    type: 'component',
+    
+    beginLayout: function(ownerContext) {
+        var me = this,
+            owner = me.owner,
+            toolbar = owner.pagingToolbar;
+
+        me.callParent(arguments);
+        
+        if (owner.floating) {
+            ownerContext.savedXY = owner.el.getXY();
+            
+            owner.el.setXY([-9999, -9999]);
+        }
+        
+        if (toolbar) {
+            ownerContext.toolbarContext = ownerContext.context.getCmp(toolbar);
+        }
+        ownerContext.listContext = ownerContext.getEl('listEl');
+    },
+    
+    beginLayoutCycle: function(ownerContext){
+        var owner = this.owner;
+        
+        this.callParent(arguments);
+        if (ownerContext.heightModel.auto) {
+            
+            
+            
+            owner.el.setHeight('auto');
+            owner.listEl.setHeight('auto');
+        }
+    },
+
+    getLayoutItems: function() {
+        var toolbar = this.owner.pagingToolbar;
+        return toolbar ? [toolbar] : [];
+    },
+    
+    isValidParent: function() {
+        
+        
+        return true;
+    },
+
+    finishedLayout: function(ownerContext) {
+        var xy = ownerContext.savedXY;
+        
+        this.callParent(arguments);
+        if (xy) {
+            this.owner.el.setXY(xy);
+        }
+    },
+    
+    measureContentWidth: function(ownerContext) {
+        return this.owner.listEl.getWidth();
+    },
+    
+    measureContentHeight: function(ownerContext) {
+        return this.owner.listEl.getHeight();
+    },
+    
+    publishInnerHeight: function(ownerContext, height) {
+        var toolbar = ownerContext.toolbarContext,
+            toolbarHeight = 0;
+            
+        if (toolbar) {
+            toolbarHeight = toolbar.getProp('height');
+        }
+        
+        if (toolbarHeight === undefined) {
+            this.done = false;
+        } else {
+            ownerContext.listContext.setHeight(height - ownerContext.getFrameInfo().height - toolbarHeight);
+        }
+    },
+    
+    calculateOwnerHeightFromContentHeight: function(ownerContext){
+        var height = this.callParent(arguments),
+            toolbar = ownerContext.toolbarContext;
+            
+        if (toolbar) {
+            height += toolbar.getProp('height');
+        }
+        return height;
+    }
+});
+
+
+Ext.define('Ext.selection.Model', {
+    extend: 'Ext.util.Observable',
+    alternateClassName: 'Ext.AbstractSelectionModel',
+    requires: ['Ext.data.StoreManager'],
+    mixins: {
+        bindable: 'Ext.util.Bindable'    
+    },
+    
+
+    
+
+    
+    allowDeselect: false,
+
+    
+    selected: null,
+
+    
+    pruneRemoved: true,
+
+    constructor: function(cfg) {
+        var me = this;
+
+        cfg = cfg || {};
+        Ext.apply(me, cfg);
+
+        me.addEvents(
+            
+            'selectionchange',
+            
+            'focuschange'
+        );
+
+        me.modes = {
+            SINGLE: true,
+            SIMPLE: true,
+            MULTI: true
+        };
+
+        
+        me.setSelectionMode(cfg.mode || me.mode);
+
+        
+        me.selected = new Ext.util.MixedCollection();
+
+        me.callParent(arguments);
+    },
+
+    
+    bindStore: function(store, initial){
+        var me = this;
+        me.mixins.bindable.bindStore.apply(me, arguments);
+        if(me.store && !initial) {
+            me.refresh();
+        }
+    },
+    
+    getStoreListeners: function() {
+        var me = this;
+        return {
+            add: me.onStoreAdd,
+            clear: me.onStoreClear,
+            remove: me.onStoreRemove,
+            update: me.onStoreUpdate    
+        }; 
+    },
+
+    
+    selectAll: function(suppressEvent) {
+        var me = this,
+            selections = me.store.getRange(),
+            i = 0,
+            len = selections.length,
+            start = me.getSelection().length;
+
+        me.bulkChange = true;
+        for (; i < len; i++) {
+            me.doSelect(selections[i], true, suppressEvent);
+        }
+        delete me.bulkChange;
+        
+        me.maybeFireSelectionChange(me.getSelection().length !== start);
+    },
+
+    
+    deselectAll: function(suppressEvent) {
+        var me = this,
+            selections = me.getSelection(),
+            i = 0,
+            len = selections.length,
+            start = me.getSelection().length;
+
+        me.bulkChange = true;
+        for (; i < len; i++) {
+            me.doDeselect(selections[i], suppressEvent);
+        }
+        delete me.bulkChange;
+        
+        me.maybeFireSelectionChange(me.getSelection().length !== start);
+    },
+
+    
+    
+    
+    selectWithEvent: function(record, e, keepExisting) {
+        var me = this;
+
+        switch (me.selectionMode) {
+            case 'MULTI':
+                if (e.ctrlKey && me.isSelected(record)) {
+                    me.doDeselect(record, false);
+                } else if (e.shiftKey && me.lastFocused) {
+                    me.selectRange(me.lastFocused, record, e.ctrlKey);
+                } else if (e.ctrlKey) {
+                    me.doSelect(record, true, false);
+                } else if (me.isSelected(record) && !e.shiftKey && !e.ctrlKey && me.selected.getCount() > 1) {
+                    me.doSelect(record, keepExisting, false);
+                } else {
+                    me.doSelect(record, false);
+                }
+                break;
+            case 'SIMPLE':
+                if (me.isSelected(record)) {
+                    me.doDeselect(record);
+                } else {
+                    me.doSelect(record, true);
+                }
+                break;
+            case 'SINGLE':
+                
+                if (me.allowDeselect && me.isSelected(record)) {
+                    me.doDeselect(record);
+                
+                } else {
+                    me.doSelect(record, false);
+                }
+                break;
+        }
+    },
+
+    
+    selectRange : function(startRow, endRow, keepExisting, dir){
+        var me = this,
+            store = me.store,
+            selectedCount = 0,
+            i,
+            tmp,
+            dontDeselect,
+            records = [];
+
+        if (me.isLocked()){
+            return;
+        }
+
+        if (!keepExisting) {
+            me.deselectAll(true);
+        }
+
+        if (!Ext.isNumber(startRow)) {
+            startRow = store.indexOf(startRow);
+        }
+        if (!Ext.isNumber(endRow)) {
+            endRow = store.indexOf(endRow);
+        }
+
+        
+        if (startRow > endRow){
+            tmp = endRow;
+            endRow = startRow;
+            startRow = tmp;
+        }
+
+        for (i = startRow; i <= endRow; i++) {
+            if (me.isSelected(store.getAt(i))) {
+                selectedCount++;
+            }
+        }
+
+        if (!dir) {
+            dontDeselect = -1;
+        } else {
+            dontDeselect = (dir == 'up') ? startRow : endRow;
+        }
+
+        for (i = startRow; i <= endRow; i++){
+            if (selectedCount == (endRow - startRow + 1)) {
+                if (i != dontDeselect) {
+                    me.doDeselect(i, true);
+                }
+            } else {
+                records.push(store.getAt(i));
+            }
+        }
+        me.doMultiSelect(records, true);
+    },
+
+    
+    select: function(records, keepExisting, suppressEvent) {
+        
+        if (Ext.isDefined(records)) {
+            this.doSelect(records, keepExisting, suppressEvent);
+        }
+    },
+
+    
+    deselect: function(records, suppressEvent) {
+        this.doDeselect(records, suppressEvent);
+    },
+
+    doSelect: function(records, keepExisting, suppressEvent) {
+        var me = this,
+            record;
+
+        if (me.locked || !me.store) {
+            return;
+        }
+        if (typeof records === "number") {
+            records = [me.store.getAt(records)];
+        }
+        if (me.selectionMode == "SINGLE" && records) {
+            record = records.length ? records[0] : records;
+            me.doSingleSelect(record, suppressEvent);
+        } else {
+            me.doMultiSelect(records, keepExisting, suppressEvent);
+        }
+    },
+
+    doMultiSelect: function(records, keepExisting, suppressEvent) {
+        var me = this,
+            selected = me.selected,
+            change = false,
+            i = 0,
+            len, record;
+
+        if (me.locked) {
+            return;
+        }
+
+
+        records = !Ext.isArray(records) ? [records] : records;
+        len = records.length;
+        if (!keepExisting && selected.getCount() > 0) {
+            if (me.doDeselect(me.getSelection(), suppressEvent) === false) {
+                return;
+            }
+            
+        }
+
+        function commit () {
+            selected.add(record);
+            change = true;
+        }
+
+        for (; i < len; i++) {
+            record = records[i];
+            if (keepExisting && me.isSelected(record)) {
+                continue;
+            }
+            me.lastSelected = record;
+
+            me.onSelectChange(record, true, suppressEvent, commit);
+        }
+        if (!me.preventFocus) {
+            me.setLastFocused(record, suppressEvent);
+        }
+        
+        me.maybeFireSelectionChange(change && !suppressEvent);
+    },
+
+    
+    doDeselect: function(records, suppressEvent) {
+        var me = this,
+            selected = me.selected,
+            i = 0,
+            len, record,
+            attempted = 0,
+            accepted = 0;
+
+        if (me.locked || !me.store) {
+            return false;
+        }
+
+        if (typeof records === "number") {
+            records = [me.store.getAt(records)];
+        } else if (!Ext.isArray(records)) {
+            records = [records];
+        }
+
+        function commit () {
+            ++accepted;
+            selected.remove(record);
+        }
+
+        len = records.length;
+
+        for (; i < len; i++) {
+            record = records[i];
+            if (me.isSelected(record)) {
+                if (me.lastSelected == record) {
+                    me.lastSelected = selected.last();
+                }
+                ++attempted;
+                me.onSelectChange(record, false, suppressEvent, commit);
+            }
+        }
+
+        
+        me.maybeFireSelectionChange(accepted > 0 && !suppressEvent);
+        return accepted === attempted;
+    },
+
+    doSingleSelect: function(record, suppressEvent) {
+        var me = this,
+            changed = false,
+            selected = me.selected;
+
+        if (me.locked) {
+            return;
+        }
+        
+        
+        if (me.isSelected(record)) {
+            return;
+        }
+
+        function commit () {
+            me.bulkChange = true;
+            if (selected.getCount() > 0 && me.doDeselect(me.lastSelected, suppressEvent) === false) {
+                delete me.bulkChange;
+                return false;
+            }
+            delete me.bulkChange;
+
+            selected.add(record);
+            me.lastSelected = record;
+            changed = true;
+        }
+
+        me.onSelectChange(record, true, suppressEvent, commit);
+
+        if (changed) {
+            if (!suppressEvent) {
+                me.setLastFocused(record);
+            }
+            me.maybeFireSelectionChange(!suppressEvent);
+        }
+    },
+
+    
+    setLastFocused: function(record, supressFocus) {
+        var me = this,
+            recordBeforeLast = me.lastFocused;
+
+        me.lastFocused = record;
+         
+        
+        if (record !== recordBeforeLast) {
+            me.onLastFocusChanged(recordBeforeLast, record, supressFocus);
+        }
+    },
+
+    
+    isFocused: function(record) {
+        return record === this.getLastFocused();
+    },
+
+
+    
+    
+    maybeFireSelectionChange: function(fireEvent) {
+        var me = this;
+        if (fireEvent && !me.bulkChange) {
+            me.fireEvent('selectionchange', me, me.getSelection());
+        }
+    },
+
+    
+    getLastSelected: function() {
+        return this.lastSelected;
+    },
+
+    getLastFocused: function() {
+        return this.lastFocused;
+    },
+
+    
+    getSelection: function() {
+        return this.selected.getRange();
+    },
+
+    
+    getSelectionMode: function() {
+        return this.selectionMode;
+    },
+
+    
+    setSelectionMode: function(selMode) {
+        selMode = selMode ? selMode.toUpperCase() : 'SINGLE';
+        
+        
+        this.selectionMode = this.modes[selMode] ? selMode : 'SINGLE';
+    },
+
+    
+    isLocked: function() {
+        return this.locked;
+    },
+
+    
+    setLocked: function(locked) {
+        this.locked = !!locked;
+    },
+
+    
+    isSelected: function(record) {
+        record = Ext.isNumber(record) ? this.store.getAt(record) : record;
+        return this.selected.indexOf(record) !== -1;
+    },
+
+    
+    hasSelection: function() {
+        return this.selected.getCount() > 0;
+    },
+
+    refresh: function() {
+        var me = this,
+            store = me.store,
+            toBeSelected = [],
+            oldSelections = me.getSelection(),
+            len = oldSelections.length,
+            selection,
+            change,
+            i = 0,
+            lastFocused = me.getLastFocused();
+
+        
+        if (!store) {
+            return;
+        }
+
+        
+        
+        
+        for (; i < len; i++) {
+            selection = oldSelections[i];
+            if (!me.pruneRemoved || store.indexOf(selection) !== -1) {
+                toBeSelected.push(selection);
+            }
+        }
+
+        
+        
+        if (me.selected.getCount() != toBeSelected.length) {
+            change = true;
+        }
+
+        me.clearSelections();
+
+        if (store.indexOf(lastFocused) !== -1) {
+            
+            me.setLastFocused(lastFocused, true);
+        }
+
+        if (toBeSelected.length) {
+            
+            me.doSelect(toBeSelected, false, true);
+        }
+
+        me.maybeFireSelectionChange(change);
+    },
+
+    
+    clearSelections: function() {
+        
+        this.selected.clear();
+        this.lastSelected = null;
+        this.setLastFocused(null);
+    },
+
+    
+    onStoreAdd: Ext.emptyFn,
+
+    
+    
+    onStoreClear: function() {
+        if (this.selected.getCount > 0) {
+            this.clearSelections();
+            this.maybeFireSelectionChange(true);
+        }
+    },
+
+    
+    
+    
+    onStoreRemove: function(store, record, index) {
+        var me = this,
+            selected = me.selected;
+
+        if (me.locked || !me.pruneRemoved) {
+            return;
+        }
+
+        if (selected.remove(record)) {
+            if (me.lastSelected == record) {
+                me.lastSelected = null;
+            }
+            if (me.getLastFocused() == record) {
+                me.setLastFocused(null);
+            }
+            me.maybeFireSelectionChange(true);
+        }
+    },
+
+    
+    getCount: function() {
+        return this.selected.getCount();
+    },
+
+    
+    destroy: Ext.emptyFn,
+
+    
+    onStoreUpdate: Ext.emptyFn,
+
+    
+    onStoreLoad: Ext.emptyFn,
+
+    
+    onSelectChange: Ext.emptyFn,
+
+    
+    onLastFocusChanged: function(oldFocused, newFocused) {
+        this.fireEvent('focuschange', this, oldFocused, newFocused);
+    },
+
+    
+    onEditorKey: Ext.emptyFn,
+
+    
+    bindComponent: Ext.emptyFn,
+
+    
+    beforeViewRender: Ext.emptyFn
+
+});
+
+
+Ext.define('Ext.selection.DataViewModel', {
+    extend: 'Ext.selection.Model',
+
+    requires: ['Ext.util.KeyNav'],
+
+    deselectOnContainerClick: true,
+
+    
+    enableKeyNav: true,
+
+    constructor: function(cfg){
+        this.addEvents(
+            
+            'beforedeselect',
+
+            
+            'beforeselect',
+
+            
+            'deselect',
+
+            
+            'select'
+        );
+        this.callParent(arguments);
+    },
+
+    bindComponent: function(view) {
+        var me = this,
+            eventListeners = {
+                refresh: me.refresh,
+                scope: me
+            };
+
+        me.view = view;
+        me.bindStore(view.getStore());
+
+        eventListeners[view.triggerEvent] = me.onItemClick;
+        eventListeners[view.triggerCtEvent] = me.onContainerClick;
+
+        view.on(eventListeners);
+
+        if (me.enableKeyNav) {
+            me.initKeyNav(view);
+        }
+    },
+
+    onItemClick: function(view, record, item, index, e) {
+        this.selectWithEvent(record, e);
+    },
+
+    onContainerClick: function() {
+        if (this.deselectOnContainerClick) {
+            this.deselectAll();
+        }
+    },
+
+    initKeyNav: function(view) {
+        var me = this;
+
+        if (!view.rendered) {
+            view.on({
+                render: Ext.Function.bind(me.initKeyNav, me, [view]),
+                single: true
+            });
+            return;
+        }
+
+        view.el.set({
+            tabIndex: -1
+        });
+        me.keyNav = new Ext.util.KeyNav({
+            target: view.el,
+            ignoreInputFields: true,
+            down: Ext.pass(me.onNavKey, [1], me),
+            right: Ext.pass(me.onNavKey, [1], me),
+            left: Ext.pass(me.onNavKey, [-1], me),
+            up: Ext.pass(me.onNavKey, [-1], me),
+            scope: me
+        });
+    },
+
+    onNavKey: function(step) {
+        step = step || 1;
+        var me = this,
+            view = me.view,
+            selected = me.getSelection()[0],
+            numRecords = me.view.store.getCount(),
+            idx;
+
+        if (selected) {
+            idx = view.indexOf(view.getNode(selected)) + step;
+        } else {
+            idx = 0;
+        }
+
+        if (idx < 0) {
+            idx = numRecords - 1;
+        } else if (idx >= numRecords) {
+            idx = 0;
+        }
+
+        me.select(idx);
+    },
+
+    
+    onSelectChange: function(record, isSelected, suppressEvent, commitFn) {
+        var me = this,
+            view = me.view,
+            eventName = isSelected ? 'select' : 'deselect';
+
+        if ((suppressEvent || me.fireEvent('before' + eventName, me, record)) !== false &&
+                commitFn() !== false) {
+
+            if (view) {
+                if (isSelected) {
+                    view.onItemSelect(record);
+                } else {
+                    view.onItemDeselect(record);
+                }
+            }
+
+            if (!suppressEvent) {
+                me.fireEvent(eventName, me, record);
+            }
+        }
+    },
+    
+    destroy: function(){
+        Ext.destroy(this.keyNav);
+        this.callParent();
+    }
+});
+
+
+Ext.define('Ext.view.AbstractView', {
+    extend: 'Ext.Component',
+    requires: [
+        'Ext.LoadMask',
+        'Ext.data.StoreManager',
+        'Ext.CompositeElementLite',
+        'Ext.DomQuery',
+        'Ext.selection.DataViewModel'
+    ],
+    mixins: {
+        bindable: 'Ext.util.Bindable'
+    },
+
+    inheritableStatics: {
+        getRecord: function(node) {
+            return this.getBoundView(node).getRecord(node);
+        },
+
+        getBoundView: function(node) {
+            return Ext.getCmp(node.boundView);
+        }
+    },
+
+    
+    
+
+    
+    deferInitialRefresh: true,
+
+    
+
+    
+    itemCls: Ext.baseCSSPrefix + 'dataview-item',
+
+    
+
+    
+
+    
+    
+    loadingText: 'Loading...',
+    
+
+    
+    loadMask: true,
+
+    
+
+    
+    loadingUseMsg: true,
+
+
+    
+
+    
+    selectedItemCls: Ext.baseCSSPrefix + 'item-selected',
+
+    
+    
+    emptyText: "",
+    
+
+    
+    deferEmptyText: true,
+
+    
+    trackOver: false,
+
+    
+    blockRefresh: false,
+
+    
+
+    
+    preserveScrollOnRefresh: false,
+
+    
+    last: false,
+
+    triggerEvent: 'itemclick',
+    triggerCtEvent: 'containerclick',
+
+    addCmpEvents: function() {
+
+    },
+
+    
+    initComponent : function(){
+        var me = this,
+            isDef = Ext.isDefined,
+            itemTpl = me.itemTpl,
+            memberFn = {};
+
+        if (itemTpl) {
+            if (Ext.isArray(itemTpl)) {
+                
+                itemTpl = itemTpl.join('');
+            } else if (Ext.isObject(itemTpl)) {
+                
+                memberFn = Ext.apply(memberFn, itemTpl.initialConfig);
+                itemTpl = itemTpl.html;
+            }
+
+            if (!me.itemSelector) {
+                me.itemSelector = '.' + me.itemCls;
+            }
+
+            itemTpl = Ext.String.format('<tpl for="."><div class="{0}">{1}</div></tpl>', me.itemCls, itemTpl);
+            me.tpl = new Ext.XTemplate(itemTpl, memberFn);
+        }
+
+
+        me.callParent();
+        if(Ext.isString(me.tpl) || Ext.isArray(me.tpl)){
+            me.tpl = new Ext.XTemplate(me.tpl);
+        }
+
+
+        me.addEvents(
+            
+            'beforerefresh',
+            
+            'refresh',
+            
+            'viewready',
+            
+            'itemupdate',
+            
+            'itemadd',
+            
+            'itemremove'
+        );
+
+        me.addCmpEvents();
+
+        
+        me.store = Ext.data.StoreManager.lookup(me.store || 'ext-empty-store');
+        me.bindStore(me.store, true);
+        me.all = new Ext.CompositeElementLite();
+
+        
+        me.scrollState = {
+            top: 0,
+            left: 0
+        };
+        me.on({
+            scroll: me.onViewScroll,
+            element: 'el',
+            scope: me
+        });
+    },
+
+    onRender: function() {
+        var me = this,
+            mask = me.loadMask,
+            cfg = {
+                msg: me.loadingText,
+                msgCls: me.loadingCls,
+                useMsg: me.loadingUseMsg,
+                
+                
+                store: me.getMaskStore()
+            };
+
+        me.callParent(arguments);
+
+        if (mask) {
+            
+            if (Ext.isObject(mask)) {
+                cfg = Ext.apply(cfg, mask);
+            }
+            
+            
+            
+            
+            me.loadMask = new Ext.LoadMask(me, cfg);
+            me.loadMask.on({
+                scope: me,
+                beforeshow: me.onMaskBeforeShow,
+                hide: me.onMaskHide
+            });
+        }
+    },
+    
+    finishRender: function(){
+        var me = this;
+        me.callParent(arguments);
+        
+        
+        if (!me.up('[collapsed],[hidden]')) {
+            me.doFirstRefresh(me.store);
+        }
+    },
+
+    onBoxReady: function() {
+        var me = this;
+
+        me.callParent(arguments);
+
+        
+        
+        if (!me.firstRefreshDone) {
+            me.doFirstRefresh(me.store);
+        }
+    },
+    
+    getMaskStore: function(){
+        return this.store;    
+    },
+    
+    onMaskBeforeShow: function(){
+        var me = this,
+            loadingHeight = me.loadingHeight;
+
+        me.getSelectionModel().deselectAll();
+        me.all.clear();
+        if (loadingHeight && loadingHeight > me.getHeight()) {
+            me.hasLoadingHeight = true;
+            me.oldMinHeight = me.minHeight;
+            me.minHeight = loadingHeight;
+            me.updateLayout();
+        }
+    },
+
+    onMaskHide: function(){
+        var me = this;
+
+        if (!me.destroying && me.hasLoadingHeight) {
+            me.minHeight = me.oldMinHeight;
+            me.updateLayout();
+            delete me.hasLoadingHeight;
+        }
+    },
+
+    beforeRender: function() {
+        this.callParent(arguments);
+        this.getSelectionModel().beforeViewRender(this);
+    },
+
+    afterRender: function() {
+        this.callParent(arguments);
+
+        
+        
+        
+        this.getSelectionModel().bindComponent(this);
+    },
+
+    
+    getSelectionModel: function(){
+        var me = this,
+            mode = 'SINGLE';
+
+        if (!me.selModel) {
+            me.selModel = {};
+        }
+
+        if (me.simpleSelect) {
+            mode = 'SIMPLE';
+        } else if (me.multiSelect) {
+            mode = 'MULTI';
+        }
+
+        Ext.applyIf(me.selModel, {
+            allowDeselect: me.allowDeselect,
+            mode: mode
+        });
+
+        if (!me.selModel.events) {
+            me.selModel = new Ext.selection.DataViewModel(me.selModel);
+        }
+
+        if (!me.selModel.hasRelaySetup) {
+            me.relayEvents(me.selModel, [
+                'selectionchange', 'beforeselect', 'beforedeselect', 'select', 'deselect', 'focuschange'
+            ]);
+            me.selModel.hasRelaySetup = true;
+        }
+
+        
+        
+        if (me.disableSelection) {
+            me.selModel.locked = true;
+        }
+
+        return me.selModel;
+    },
+
+    
+    refresh: function() {
+        var me = this,
+            targetEl,
+            targetParent,
+            oldDisplay,
+            nextSibling,
+            dom,
+            records;
+
+        if (!me.rendered || me.isDestroyed) {
+            return;
+        }
+
+        if (!me.hasListeners.beforerefresh || me.fireEvent('beforerefresh', me) !== false) {
+            targetEl = me.getTargetEl();
+            records = me.store.getRange();
+            dom = targetEl.dom;
+
+            
+            
+            if (!me.preserveScrollOnRefresh) {
+                targetParent = dom.parentNode;
+                oldDisplay = dom.style.display;
+                dom.style.display = 'none';
+                nextSibling = dom.nextSibling;
+                targetParent.removeChild(dom);
+            }
+
+            if (me.refreshCounter) {
+                me.clearViewEl();
+            } else {
+                me.fixedNodes = targetEl.dom.childNodes.length;
+                me.refreshCounter = 1;
+            }
+
+            
+            
+            
+            
+            me.tpl.append(targetEl, me.collectData(records, 0));
+
+            
+            
+            if (records.length < 1) {
+                if (!me.deferEmptyText || me.hasSkippedEmptyText) {
+                    Ext.core.DomHelper.insertHtml('beforeEnd', targetEl.dom, me.emptyText);
+                }
+                me.all.clear();
+            } else {
+                me.all.fill(Ext.query(me.getItemSelector(), targetEl.dom));
+                me.updateIndexes(0);
+            }
+
+            me.selModel.refresh();
+            me.hasSkippedEmptyText = true;
+
+            if (!me.preserveScrollOnRefresh) {
+                targetParent.insertBefore(dom, nextSibling);
+                dom.style.display = oldDisplay;
+            }
+
+            
+            this.refreshSize();
+
+            me.fireEvent('refresh', me);
+
+            
+            
+            if (!me.viewReady) {
+                
+                
+                me.viewReady = true;
+                me.fireEvent('viewready', me);
+            }
+        }
+    },
+
+    
+    refreshSize: function() {
+        var sizeModel = this.getSizeModel();
+        if (sizeModel.height.shrinkWrap || sizeModel.width.shrinkWrap) {
+            this.updateLayout();
+        }
+    },
+
+    clearViewEl: function(){
+        
+        
+        
+        
+        
+        
+        
+
+        var me = this,
+            el = me.getTargetEl();
+
+        if (me.fixedNodes) {
+            while (el.dom.childNodes[me.fixedNodes]) {
+                el.dom.removeChild(el.dom.childNodes[me.fixedNodes]);
+            }
+        } else {
+            el.update('');
+        }
+        me.refreshCounter++;
+    },
+
+    
+    onViewScroll: Ext.emptyFn,
+
+    
+    saveScrollState: function() {
+        if (this.rendered) {
+            var dom = this.el.dom,
+                state = this.scrollState;
+
+            state.left = dom.scrollLeft;
+            state.top = dom.scrollTop;
+        }
+    },
+
+    
+    restoreScrollState: function() {
+        if (this.rendered) {
+            var dom = this.el.dom, 
+                state = this.scrollState;
+
+            dom.scrollLeft = state.left;
+            dom.scrollTop = state.top;
+        }
+    },
+
+    
+    prepareData: function(data, index, record) {
+        var associatedData, attr;
+        if (record) {
+            associatedData = record.getAssociatedData();
+            for (attr in associatedData) {
+                if (associatedData.hasOwnProperty(attr)) {
+                    data[attr] = associatedData[attr];
+                }
+            }
+        }
+        return data;
+    },
+
+    
+    collectData : function(records, startIndex){
+        var data = [],
+            i = 0,
+            len = records.length,
+            record;
+
+        for (; i < len; i++) {
+            record = records[i];
+            data[i] = this.prepareData(record.data, startIndex + i, record);
+        }
+        return data;
+    },
+
+    
+    bufferRender : function(records, index){
+        var me = this,
+            div = me.renderBuffer || (me.renderBuffer = document.createElement('div'));
+
+        me.tpl.overwrite(div, me.collectData(records, index));
+        return Ext.query(me.getItemSelector(), div);
+    },
+
+    
+    onUpdate : function(ds, record){
+        var me = this,
+            index,
+            node;
+
+        if (me.viewReady) {
+            index = me.store.indexOf(record);
+            if (index > -1) {
+                node = me.bufferRender([record], index)[0];
+                
+                if (me.getNode(record)) {
+                    me.all.replaceElement(index, node, true);
+                    me.updateIndexes(index, index);
+                    
+                    
+                    me.selModel.refresh();
+                    if (me.hasListeners.itemupdate) {
+                        me.fireEvent('itemupdate', record, index, node);
+                    }
+                    return node;
+                }
+            }
+        }
+
+    },
+
+    
+    onAdd : function(ds, records, index) {
+        var me = this,
+            nodes;
+
+        if (me.rendered) {
+            
+            
+            if (me.all.getCount() === 0) {
+                me.refresh();
+                return;
+            }
+
+            nodes = me.bufferRender(records, index);
+            me.doAdd(nodes, records, index);
+
+            me.selModel.refresh();
+            me.updateIndexes(index);
+
+            
+            me.refreshSize();
+
+            if (me.hasListeners.itemadd) {
+                me.fireEvent('itemadd', records, index, nodes);
+            }
+        }
+
+    },
+
+    doAdd: function(nodes, records, index) {
+        var all = this.all,
+            count = all.getCount();
+
+        if (count === 0) {
+            this.clearViewEl();
+            this.getTargetEl().appendChild(nodes);
+        } else if (index < count) {
+            if (index === 0) {
+                all.item(index).insertSibling(nodes, 'before', true);
+            } else {
+                all.item(index - 1).insertSibling(nodes, 'after', true);
+            }
+        } else {
+            all.last().insertSibling(nodes, 'after', true);
+        }
+
+        Ext.Array.insert(all.elements, index, nodes);
+    },
+
+    
+    onRemove : function(ds, record, index) {
+        var me = this;
+
+        if (me.all.getCount()) {
+            if (me.store.getCount() === 0) {
+                
+                me.refresh();
+            } else {
+                
+                
+                me.doRemove(record, index);
+                if (me.selModel.refreshOnRemove) {
+                    me.selModel.refresh();
+                }
+                me.updateIndexes(index);
+            }
+
+            
+            this.refreshSize();
+
+            if (me.hasListeners.itemremove) {
+                me.fireEvent('itemremove', record, index);
+            }
+        }
+    },
+
+    doRemove: function(record, index) {
+        this.all.removeElement(index, true);
+    },
+
+    
+    refreshNode : function(index){
+        this.onUpdate(this.store, this.store.getAt(index));
+    },
+
+    
+    updateIndexes : function(startIndex, endIndex) {
+        var ns = this.all.elements,
+            records = this.store.getRange(),
+            i;
+
+        startIndex = startIndex || 0;
+        endIndex = endIndex || ((endIndex === 0) ? 0 : (ns.length - 1));
+        for (i = startIndex; i <= endIndex; i++) {
+            ns[i].viewIndex = i;
+            ns[i].viewRecordId = records[i].internalId;
+            if (!ns[i].boundView) {
+                ns[i].boundView = this.id;
+            }
+        }
+    },
+
+    
+    getStore : function() {
+        return this.store;
+    },
+
+    
+    bindStore : function(store, initial) {
+        var me = this;
+        me.mixins.bindable.bindStore.apply(me, arguments);
+
+        
+        
+        if (!initial) {
+            me.getSelectionModel().bindStore(me.store);
+        }
+
+        
+        
+        
+        if (me.componentLayoutCounter) {
+            me.doFirstRefresh(store);
+        }
+    },
+
+    
+    doFirstRefresh: function(store) {
+        var me = this;
+
+        
+        me.firstRefreshDone = true;
+
+        
+        
+        
+        
+        
+        if (store && !store.loading) {
+            if (me.deferInitialRefresh) {
+                me.applyFirstRefresh();
+            } else {
+                me.refresh();
+            }
+        }
+    },
+    
+    applyFirstRefresh: function(){
+        var me = this;
+        if (me.isDestroyed) {
+            return;
+        }
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        if (me.up('[isCollapsingOrExpanding]')) {
+            Ext.Function.defer(me.applyFirstRefresh, 100, me);
+        } else {
+            Ext.Function.defer(function () {
+                if (!me.isDestroyed) {
+                    me.refresh();
+                }
+            }, 1);
+        }
+    },
+
+    onUnbindStore: function(store) {
+        this.setMaskBind(null);
+    },
+
+    onBindStore: function(store) {
+        this.setMaskBind(store);
+    },
+
+    setMaskBind: function(store) {
+        var mask = this.loadMask;
+        if (mask && mask.bindStore) {
+            mask.bindStore(store);
+        }
+    },
+
+    getStoreListeners: function() {
+        var me = this;
+        return {
+            refresh: me.onDataRefresh,
+            add: me.onAdd,
+            remove: me.onRemove,
+            update: me.onUpdate,
+            clear: me.refresh
+        };
+    },
+
+    
+    onDataRefresh: function() {
+        var me = this,
+            
+            
+            blockedByAncestor = !me.firstRefreshDone && (!me.rendered || me.up('[collapsed],[isCollapsingOrExpanding],[hidden]'));
+
+        
+        
+        
+        
+        if (blockedByAncestor) {
+            me.deferInitialRefresh = false;
+        } else if (me.blockRefresh !== true) {
+            me.firstRefreshDone = true;
+            me.refresh.apply(me, arguments);
+        }
+
+    },
+
+    
+    findItemByChild: function(node){
+        return Ext.fly(node).findParent(this.getItemSelector(), this.getTargetEl());
+    },
+
+    
+    findTargetByEvent: function(e) {
+        return e.getTarget(this.getItemSelector(), this.getTargetEl());
+    },
+
+
+    
+    getSelectedNodes: function(){
+        var nodes   = [],
+            records = this.selModel.getSelection(),
+            ln = records.length,
+            i  = 0;
+
+        for (; i < ln; i++) {
+            nodes.push(this.getNode(records[i]));
+        }
+
+        return nodes;
+    },
+
+    
+    getRecords: function(nodes) {
+        var records = [],
+            i = 0,
+            len = nodes.length,
+            data = this.store.data;
+
+        for (; i < len; i++) {
+            records[records.length] = data.getByKey(nodes[i].viewRecordId);
+        }
+
+        return records;
+    },
+
+    
+    getRecord: function(node){
+        return this.store.data.getByKey(Ext.getDom(node).viewRecordId);
+    },
+
+
+    
+    isSelected : function(node) {
+        
+        var r = this.getRecord(node);
+        return this.selModel.isSelected(r);
+    },
+
+    
+    select: function(records, keepExisting, suppressEvent) {
+        this.selModel.select(records, keepExisting, suppressEvent);
+    },
+
+    
+    deselect: function(records, suppressEvent) {
+        this.selModel.deselect(records, suppressEvent);
+    },
+
+    
+    getNode : function(nodeInfo) {
+        if ((!nodeInfo && nodeInfo !== 0) || !this.rendered) {
+            return null;
+        }
+
+        if (Ext.isString(nodeInfo)) {
+            return document.getElementById(nodeInfo);
+        }
+        if (Ext.isNumber(nodeInfo)) {
+            return this.all.elements[nodeInfo];
+        }
+        if (nodeInfo.isModel) {
+            return this.getNodeByRecord(nodeInfo);
+        }
+        return nodeInfo; 
+    },
+
+    
+    getNodeByRecord: function(record) {
+        var ns = this.all.elements,
+            ln = ns.length,
+            i = 0;
+
+        for (; i < ln; i++) {
+            if (ns[i].viewRecordId === record.internalId) {
+                return ns[i];
+            }
+        }
+
+        return null;
+    },
+
+    
+    getNodes: function(start, end) {
+        var ns = this.all.elements;
+
+        if (end === undefined) {
+            end = ns.length;
+        } else {
+            end++;
+        }
+        return this.all.elements.slice(start||0, end);
+    },
+
+    
+    indexOf: function(node) {
+        node = this.getNode(node);
+        if (!node && node !== 0) {
+            return -1;
+        }
+        if (Ext.isNumber(node.viewIndex)) {
+            return node.viewIndex;
+        }
+        return this.all.indexOf(node);
+    },
+
+    onDestroy : function() {
+        var me = this;
+
+        me.all.clear();
+        me.callParent();
+        me.bindStore(null);
+        me.selModel.destroy();
+    },
+
+    
+    onItemSelect: function(record) {
+        var node = this.getNode(record);
+
+        if (node) {
+            Ext.fly(node).addCls(this.selectedItemCls);
+        }
+    },
+
+    
+    onItemDeselect: function(record) {
+        var node = this.getNode(record);
+
+        if (node) {
+            Ext.fly(node).removeCls(this.selectedItemCls);
+        }
+    },
+
+    getItemSelector: function() {
+        return this.itemSelector;
+    }
+}, function() {
+    
+    
+    
+    
+    Ext.deprecate('extjs', '4.0', function() {
+        Ext.view.AbstractView.override({
+            
+            
+            
+
+            
+            getSelectionCount : function(){
+                if (Ext.global.console) {
+                    Ext.global.console.warn("DataView: getSelectionCount will be removed, please interact with the Ext.selection.DataViewModel");
+                }
+                return this.selModel.getSelection().length;
+            },
+
+            
+            getSelectedRecords : function(){
+                if (Ext.global.console) {
+                    Ext.global.console.warn("DataView: getSelectedRecords will be removed, please interact with the Ext.selection.DataViewModel");
+                }
+                return this.selModel.getSelection();
+            },
+
+            select: function(records, keepExisting, supressEvents) {
+                if (Ext.global.console) {
+                    Ext.global.console.warn("DataView: select will be removed, please access select through a DataView's SelectionModel, ie: view.getSelectionModel().select()");
+                }
+                var sm = this.getSelectionModel();
+                return sm.select.apply(sm, arguments);
+            },
+
+            
+            clearSelections: function() {
+                if (Ext.global.console) {
+                    Ext.global.console.warn("DataView: clearSelections will be removed, please access deselectAll through DataView's SelectionModel, ie: view.getSelectionModel().deselectAll()");
+                }
+                var sm = this.getSelectionModel();
+                return sm.deselectAll();
+            }
+        });
+    });
+});
+
+
+Ext.define('Ext.view.View', {
+    extend: 'Ext.view.AbstractView',
+    alternateClassName: 'Ext.DataView',
+    alias: 'widget.dataview',
+
+    deferHighlight: (Ext.isIE6 || Ext.isIE7) ? 100 : 0,
+
+    inputTagRe: /^textarea$|^input$/i,
+
+    inheritableStatics: {
+        EventMap: {
+            mousedown: 'MouseDown',
+            mouseup: 'MouseUp',
+            click: 'Click',
+            dblclick: 'DblClick',
+            contextmenu: 'ContextMenu',
+            mouseover: 'MouseOver',
+            mouseout: 'MouseOut',
+            mouseenter: 'MouseEnter',
+            mouseleave: 'MouseLeave',
+            keydown: 'KeyDown',
+            focus: 'Focus'
+        }
+    },
+
+    initComponent: function() {
+        var me = this;
+        me.callParent();
+        if (me.deferHighlight){
+            me.setHighlightedItem =
+                Ext.Function.createBuffered(me.setHighlightedItem, me.deferHighlight, me);
+        }
+    },
+
+    addCmpEvents: function() {
+        this.addEvents(
+            
+            'beforeitemmousedown',
+            
+            'beforeitemmouseup',
+            
+            'beforeitemmouseenter',
+            
+            'beforeitemmouseleave',
+            
+            'beforeitemclick',
+            
+            'beforeitemdblclick',
+            
+            'beforeitemcontextmenu',
+            
+            'beforeitemkeydown',
+            
+            'itemmousedown',
+            
+            'itemmouseup',
+            
+            'itemmouseenter',
+            
+            'itemmouseleave',
+            
+            'itemclick',
+            
+            'itemdblclick',
+            
+            'itemcontextmenu',
+            
+            'itemkeydown',
+            
+            'beforecontainermousedown',
+            
+            'beforecontainermouseup',
+            
+            'beforecontainermouseover',
+            
+            'beforecontainermouseout',
+            
+            'beforecontainerclick',
+            
+            'beforecontainerdblclick',
+            
+            'beforecontainercontextmenu',
+            
+            'beforecontainerkeydown',
+            
+            'containermouseup',
+            
+            'containermouseover',
+            
+            'containermouseout',
+            
+            'containerclick',
+            
+            'containerdblclick',
+            
+            'containercontextmenu',
+            
+            'containerkeydown',
+
+            
+            'selectionchange',
+            
+            'beforeselect',
+            
+            'beforedeselect',
+            
+            'select',
+            
+            'deselect',
+            
+            'focuschange',
+            
+            
+            'highlightitem',
+            
+            
+            'unhighlightitem'
+        );
+    },
+
+    getFocusEl: function() {
+        return this.getTargetEl();
+    },
+
+    
+    afterRender: function(){
+        var me = this;
+        me.callParent();
+        me.mon(me.getTargetEl(), {
+            scope: me,
+            
+            freezeEvent: true,
+            click: me.handleEvent,
+            mousedown: me.handleEvent,
+            mouseup: me.handleEvent,
+            dblclick: me.handleEvent,
+            contextmenu: me.handleEvent,
+            mouseover: me.handleEvent,
+            mouseout: me.handleEvent,
+            keydown: me.handleEvent
+        });
+    },
+
+    handleEvent: function(e) {
+        var me = this,
+            key = e.type == 'keydown' && e.getKey();
+
+        if (me.processUIEvent(e) !== false) {
+            me.processSpecialEvent(e);
+        }
+
+        
+        
+        
+        if (key === e.SPACE) {
+            if (!me.inputTagRe.test(e.getTarget().tagName)) {
+                e.stopEvent();
+            }
+        }
+    },
+
+    
+    processItemEvent: Ext.emptyFn,
+    processContainerEvent: Ext.emptyFn,
+    processSpecialEvent: Ext.emptyFn,
+
+    
+    stillOverItem: function (event, overItem) {
+        var nowOver;
+
+        
+        
+        
+        
+        
+        
+        if (overItem && typeof(overItem.offsetParent) === "object") {
+            
+            
+            nowOver = (event.type == 'mouseout') ? event.getRelatedTarget() : event.getTarget();
+            return Ext.fly(overItem).contains(nowOver);
+        }
+
+        return false;
+    },
+
+    processUIEvent: function(e) {
+        var me = this,
+            item = e.getTarget(me.getItemSelector(), me.getTargetEl()),
+            map = this.statics().EventMap,
+            index, record,
+            type = e.type,
+            overItem = me.mouseOverItem,
+            newType;
+
+        if (!item) {
+            if (type == 'mouseover' && me.stillOverItem(e, overItem)) {
+                item = overItem;
+            }
+
+            
+            if (type == 'keydown') {
+                record = me.getSelectionModel().getLastSelected();
+                if (record) {
+                    item = me.getNode(record);
+                }
+            }
+        }
+
+        if (item) {
+            index = me.indexOf(item);
+            if (!record) {
+                record = me.getRecord(item);
+            }
+
+            
+            
+            
+            if (!record || me.processItemEvent(record, item, index, e) === false) {
+                return false;
+            }
+
+            newType = me.isNewItemEvent(item, e);
+            if (newType === false) {
+                return false;
+            }
+
+            if (
+                (me['onBeforeItem' + map[newType]](record, item, index, e) === false) ||
+                (me.fireEvent('beforeitem' + newType, me, record, item, index, e) === false) ||
+                (me['onItem' + map[newType]](record, item, index, e) === false)
+            ) {
+                return false;
+            }
+
+            me.fireEvent('item' + newType, me, record, item, index, e);
+        }
+        else {
+            if (
+                (me.processContainerEvent(e) === false) ||
+                (me['onBeforeContainer' + map[type]](e) === false) ||
+                (me.fireEvent('beforecontainer' + type, me, e) === false) ||
+                (me['onContainer' + map[type]](e) === false)
+            ) {
+                return false;
+            }
+
+            me.fireEvent('container' + type, me, e);
+        }
+
+        return true;
+    },
+
+    isNewItemEvent: function (item, e) {
+        var me = this,
+            overItem = me.mouseOverItem,
+            type = e.type;
+
+        switch (type) {
+            case 'mouseover':
+                if (item === overItem) {
+                    return false;
+                }
+                me.mouseOverItem = item;
+                return 'mouseenter';
+
+            case 'mouseout':
+                
+                if (me.stillOverItem(e, overItem)) {
+                    return false;
+                }
+                me.mouseOverItem = null;
+                return 'mouseleave';
+        }
+        return type;
+    },
+
+    
+    onItemMouseEnter: function(record, item, index, e) {
+        if (this.trackOver) {
+            this.highlightItem(item);
+        }
+    },
+
+    
+    onItemMouseLeave : function(record, item, index, e) {
+        if (this.trackOver) {
+            this.clearHighlight();
+        }
+    },
+
+    
+    onItemMouseDown: Ext.emptyFn,
+    onItemMouseUp: Ext.emptyFn,
+    onItemFocus: Ext.emptyFn,
+    onItemClick: Ext.emptyFn,
+    onItemDblClick: Ext.emptyFn,
+    onItemContextMenu: Ext.emptyFn,
+    onItemKeyDown: Ext.emptyFn,
+    onBeforeItemMouseDown: Ext.emptyFn,
+    onBeforeItemMouseUp: Ext.emptyFn,
+    onBeforeItemFocus: Ext.emptyFn,
+    onBeforeItemMouseEnter: Ext.emptyFn,
+    onBeforeItemMouseLeave: Ext.emptyFn,
+    onBeforeItemClick: Ext.emptyFn,
+    onBeforeItemDblClick: Ext.emptyFn,
+    onBeforeItemContextMenu: Ext.emptyFn,
+    onBeforeItemKeyDown: Ext.emptyFn,
+
+    
+    onContainerMouseDown: Ext.emptyFn,
+    onContainerMouseUp: Ext.emptyFn,
+    onContainerMouseOver: Ext.emptyFn,
+    onContainerMouseOut: Ext.emptyFn,
+    onContainerClick: Ext.emptyFn,
+    onContainerDblClick: Ext.emptyFn,
+    onContainerContextMenu: Ext.emptyFn,
+    onContainerKeyDown: Ext.emptyFn,
+    onBeforeContainerMouseDown: Ext.emptyFn,
+    onBeforeContainerMouseUp: Ext.emptyFn,
+    onBeforeContainerMouseOver: Ext.emptyFn,
+    onBeforeContainerMouseOut: Ext.emptyFn,
+    onBeforeContainerClick: Ext.emptyFn,
+    onBeforeContainerDblClick: Ext.emptyFn,
+    onBeforeContainerContextMenu: Ext.emptyFn,
+    onBeforeContainerKeyDown: Ext.emptyFn,
+
+    
+    setHighlightedItem: function(item){
+        var me = this,
+            highlighted = me.highlightedItem;
+
+        if (highlighted != item){
+            if (highlighted) {
+                Ext.fly(highlighted).removeCls(me.overItemCls);
+                me.fireEvent('unhighlightitem', me, highlighted);
+            }
+
+            me.highlightedItem = item;
+
+            if (item) {
+                
+                Ext.fly(item).addCls(me.overItemCls);
+                me.fireEvent('highlightitem', me, item);
+            }
+        }
+    },
+
+    
+    highlightItem: function(item) {
+        this.setHighlightedItem(item);
+    },
+
+    
+    clearHighlight: function() {
+        this.setHighlightedItem(undefined);
+    },
+    
+    onUpdate: function(store, record){
+        var me = this,
+            node,
+            newNode,
+            highlighted;
+        
+        if (me.viewReady) {
+            node = me.getNode(record);
+            newNode = me.callParent(arguments);
+            highlighted = me.highlightedItem;
+            
+            if (highlighted && highlighted === node) {
+                delete me.highlightedItem;
+                if (newNode) {
+                    me.highlightItem(newNode);
+                }
+            }
+        }
+    },
+
+    refresh: function() {
+        this.clearHighlight();
+        this.callParent(arguments);
+    }
+});
+
+
+Ext.define('Ext.toolbar.TextItem', {
+    extend: 'Ext.toolbar.Item',
+    requires: ['Ext.XTemplate'],
+    alias: 'widget.tbtext',
+    alternateClassName: 'Ext.Toolbar.TextItem',
+
+    
+    text: '',
+
+    renderTpl: '{text}',
+    
+    baseCls: Ext.baseCSSPrefix + 'toolbar-text',
+
+    beforeRender : function() {
+        var me = this;
+
+        me.callParent();
+
+        Ext.apply(me.renderData, {
+            text: me.text
+        });
+    },
+
+    
+    setText : function(text) {
+        var me = this;
+        if (me.rendered) {
+            me.el.update(text);
+            me.updateLayout();
+        } else {
+            this.text = text;
+        }
+    }
+});
+
+
+Ext.define('Ext.form.field.Spinner', {
+    extend: 'Ext.form.field.Trigger',
+    alias: 'widget.spinnerfield',
+    alternateClassName: 'Ext.form.Spinner',
+    requires: ['Ext.util.KeyNav'],
+
+    trigger1Cls: Ext.baseCSSPrefix + 'form-spinner-up',
+    trigger2Cls: Ext.baseCSSPrefix + 'form-spinner-down',
+
+    
+    spinUpEnabled: true,
+
+    
+    spinDownEnabled: true,
+
+    
+    keyNavEnabled: true,
+
+    
+    mouseWheelEnabled: true,
+
+    
+    repeatTriggerClick: true,
+
+    
+    onSpinUp: Ext.emptyFn,
+
+    
+    onSpinDown: Ext.emptyFn,
+
+    triggerTpl: '<td style="{triggerStyle}">' +
+                    '<div class="' + Ext.baseCSSPrefix + 'trigger-index-0 ' + Ext.baseCSSPrefix + 'form-trigger ' + Ext.baseCSSPrefix + 'form-spinner-up" role="button"></div>' +
+                    '<div class="' + Ext.baseCSSPrefix + 'trigger-index-1 ' + Ext.baseCSSPrefix + 'form-trigger ' + Ext.baseCSSPrefix + 'form-spinner-down" role="button"></div>' +
+                '</td>' +
+            '</tr>',
+
+    initComponent: function() {
+        this.callParent();
+
+        this.addEvents(
+            
+            'spin',
+
+            
+            'spinup',
+
+            
+            'spindown'
+        );
+    },
+
+    
+    onRender: function() {
+        var me = this,
+            triggers;
+
+        me.callParent(arguments);
+        triggers = me.triggerEl;
+        
+        
+        me.spinUpEl = triggers.item(0);
+        
+        me.spinDownEl = triggers.item(1);
+        
+        me.triggerCell = me.spinUpEl.parent(); 
+
+        
+        me.setSpinUpEnabled(me.spinUpEnabled);
+        me.setSpinDownEnabled(me.spinDownEnabled);
+
+        
+        if (me.keyNavEnabled) {
+            me.spinnerKeyNav = new Ext.util.KeyNav(me.inputEl, {
+                scope: me,
+                up: me.spinUp,
+                down: me.spinDown
+            });
+        }
+
+        
+        if (me.mouseWheelEnabled) {
+            me.mon(me.bodyEl, 'mousewheel', me.onMouseWheel, me);
+        }
+    },
+
+    getSubTplMarkup: function() {
+        var me = this,
+            field = Ext.form.field.Base.prototype.getSubTplMarkup.apply(me, arguments);
+
+        return '<table id="' + me.id + '-triggerWrap" class="' + Ext.baseCSSPrefix + 'form-trigger-wrap" cellpadding="0" cellspacing="0">' +
+            '<tbody>' +
+                '<tr><td id="' + me.id + '-inputCell" class="' + Ext.baseCSSPrefix + 'form-trigger-input-cell">' + field + '</td>' +
+                me.getTriggerMarkup() +
+            '</tbody></table>';
+    },
+
+    getTriggerMarkup: function() {
+        var me = this,
+            hideTrigger = (me.readOnly || me.hideTrigger);
+
+        return me.getTpl('triggerTpl').apply({
+            triggerStyle: 'width:' + me.triggerWidth + (hideTrigger ? 'px;display:none' : 'px')
+        });
+    },
+
+    
+    getTriggerWidth: function() {
+        var me = this,
+            totalTriggerWidth = 0;
+
+        if (me.triggerWrap && !me.hideTrigger && !me.readOnly) {
+            totalTriggerWidth = me.triggerWidth;
+        }
+        return totalTriggerWidth;
+    },
+
+    
+    onTrigger1Click: function() {
+        this.spinUp();
+    },
+
+    
+    onTrigger2Click: function() {
+        this.spinDown();
+    },
+
+    
+    
+    onTriggerWrapMouseup: function() {
+        this.inputEl.focus();
+    },
+
+    
+    spinUp: function() {
+        var me = this;
+        if (me.spinUpEnabled && !me.disabled) {
+            me.fireEvent('spin', me, 'up');
+            me.fireEvent('spinup', me);
+            me.onSpinUp();
+        }
+    },
+
+    
+    spinDown: function() {
+        var me = this;
+        if (me.spinDownEnabled && !me.disabled) {
+            me.fireEvent('spin', me, 'down');
+            me.fireEvent('spindown', me);
+            me.onSpinDown();
+        }
+    },
+
+    
+    setSpinUpEnabled: function(enabled) {
+        var me = this,
+            wasEnabled = me.spinUpEnabled;
+        me.spinUpEnabled = enabled;
+        if (wasEnabled !== enabled && me.rendered) {
+            me.spinUpEl[enabled ? 'removeCls' : 'addCls'](me.trigger1Cls + '-disabled');
+        }
+    },
+
+    
+    setSpinDownEnabled: function(enabled) {
+        var me = this,
+            wasEnabled = me.spinDownEnabled;
+        me.spinDownEnabled = enabled;
+        if (wasEnabled !== enabled && me.rendered) {
+            me.spinDownEl[enabled ? 'removeCls' : 'addCls'](me.trigger2Cls + '-disabled');
+        }
+    },
+
+    
+    onMouseWheel: function(e) {
+        var me = this,
+            delta;
+        if (me.hasFocus) {
+            delta = e.getWheelDelta();
+            if (delta > 0) {
+                me.spinUp();
+            }
+            else if (delta < 0) {
+                me.spinDown();
+            }
+            e.stopEvent();
+        }
+    },
+
+    onDestroy: function() {
+        Ext.destroyMembers(this, 'spinnerKeyNav', 'spinUpEl', 'spinDownEl');
+        this.callParent();
+    }
+
+});
+
+
+Ext.define('Ext.form.field.Number', {
+    extend:'Ext.form.field.Spinner',
+    alias: 'widget.numberfield',
+    alternateClassName: ['Ext.form.NumberField', 'Ext.form.Number'],
+
+    
+    
+
+    
+    allowDecimals : true,
+
+    
+    
+    decimalSeparator : '.',
+    
+    
+    
+    
+    submitLocaleSeparator: true,
+    
+
+    
+    
+    decimalPrecision : 2,
+    
+
+    
+    minValue: Number.NEGATIVE_INFINITY,
+
+    
+    maxValue: Number.MAX_VALUE,
+
+    
+    step: 1,
+
+    
+    
+    minText : 'The minimum value for this field is {0}',
+    
+
+    
+    
+    maxText : 'The maximum value for this field is {0}',
+    
+
+    
+    
+    nanText : '{0} is not a valid number',
+    
+
+    
+    
+    negativeText : 'The value cannot be negative',
+    
+
+    
+    baseChars : '0123456789',
+
+    
+    autoStripChars: false,
+
+    initComponent: function() {
+        var me = this,
+            allowed;
+
+        me.callParent();
+
+        me.setMinValue(me.minValue);
+        me.setMaxValue(me.maxValue);
+
+        
+        if (me.disableKeyFilter !== true) {
+            allowed = me.baseChars + '';
+            if (me.allowDecimals) {
+                allowed += me.decimalSeparator;
+            }
+            if (me.minValue < 0) {
+                allowed += '-';
+            }
+            allowed = Ext.String.escapeRegex(allowed);
+            me.maskRe = new RegExp('[' + allowed + ']');
+            if (me.autoStripChars) {
+                me.stripCharsRe = new RegExp('[^' + allowed + ']', 'gi');
+            }
+        }
+    },
+
+    
+    getErrors: function(value) {
+        var me = this,
+            errors = me.callParent(arguments),
+            format = Ext.String.format,
+            num;
+
+        value = Ext.isDefined(value) ? value : this.processRawValue(this.getRawValue());
+
+        if (value.length < 1) { 
+             return errors;
+        }
+
+        value = String(value).replace(me.decimalSeparator, '.');
+
+        if(isNaN(value)){
+            errors.push(format(me.nanText, value));
+        }
+
+        num = me.parseValue(value);
+
+        if (me.minValue === 0 && num < 0) {
+            errors.push(this.negativeText);
+        }
+        else if (num < me.minValue) {
+            errors.push(format(me.minText, me.minValue));
+        }
+
+        if (num > me.maxValue) {
+            errors.push(format(me.maxText, me.maxValue));
+        }
+
+
+        return errors;
+    },
+
+    rawToValue: function(rawValue) {
+        var value = this.fixPrecision(this.parseValue(rawValue));
+        if (value === null) {
+            value = rawValue || null;
+        }
+        return  value;
+    },
+
+    valueToRaw: function(value) {
+        var me = this,
+            decimalSeparator = me.decimalSeparator;
+        value = me.parseValue(value);
+        value = me.fixPrecision(value);
+        value = Ext.isNumber(value) ? value : parseFloat(String(value).replace(decimalSeparator, '.'));
+        value = isNaN(value) ? '' : String(value).replace('.', decimalSeparator);
+        return value;
+    },
+    
+    getSubmitValue: function() {
+        var me = this,
+            value = me.callParent();
+            
+        if (!me.submitLocaleSeparator) {
+            value = value.replace(me.decimalSeparator, '.');
+        }  
+        return value;
+    },
+
+    onChange: function() {
+        this.toggleSpinners();
+        this.callParent(arguments);
+    },
+    
+    toggleSpinners: function(){
+        var me = this,
+            value = me.getValue(),
+            valueIsNull = value === null;
+            
+        me.setSpinUpEnabled(valueIsNull || value < me.maxValue);
+        me.setSpinDownEnabled(valueIsNull || value > me.minValue);
+    },
+
+    
+    setMinValue : function(value) {
+        this.minValue = Ext.Number.from(value, Number.NEGATIVE_INFINITY);
+        this.toggleSpinners();
+    },
+
+    
+    setMaxValue: function(value) {
+        this.maxValue = Ext.Number.from(value, Number.MAX_VALUE);
+        this.toggleSpinners();
+    },
+
+    
+    parseValue : function(value) {
+        value = parseFloat(String(value).replace(this.decimalSeparator, '.'));
+        return isNaN(value) ? null : value;
+    },
+
+    
+    fixPrecision : function(value) {
+        var me = this,
+            nan = isNaN(value),
+            precision = me.decimalPrecision;
+
+        if (nan || !value) {
+            return nan ? '' : value;
+        } else if (!me.allowDecimals || precision <= 0) {
+            precision = 0;
+        }
+
+        return parseFloat(Ext.Number.toFixed(parseFloat(value), precision));
+    },
+
+    beforeBlur : function() {
+        var me = this,
+            v = me.parseValue(me.getRawValue());
+
+        if (!Ext.isEmpty(v)) {
+            me.setValue(v);
+        }
+    },
+
+    onSpinUp: function() {
+        var me = this;
+        if (!me.readOnly) {
+            me.setValue(Ext.Number.constrain(me.getValue() + me.step, me.minValue, me.maxValue));
+        }
+    },
+
+    onSpinDown: function() {
+        var me = this;
+        if (!me.readOnly) {
+            me.setValue(Ext.Number.constrain(me.getValue() - me.step, me.minValue, me.maxValue));
+        }
+    }
+});
+
+
+Ext.define('Ext.toolbar.Paging', {
+    extend: 'Ext.toolbar.Toolbar',
+    alias: 'widget.pagingtoolbar',
+    alternateClassName: 'Ext.PagingToolbar',
+    requires: ['Ext.toolbar.TextItem', 'Ext.form.field.Number'],
+    mixins: {
+        bindable: 'Ext.util.Bindable'    
+    },
+    
+
+    
+    displayInfo: false,
+
+    
+    prependButtons: false,
+
+    
+    
+    displayMsg : 'Displaying {0} - {1} of {2}',
+    
+
+    
+    
+    emptyMsg : 'No data to display',
+    
+
+    
+    
+    beforePageText : 'Page',
+    
+
+    
+    
+    afterPageText : 'of {0}',
+    
+
+    
+    
+    firstText : 'First Page',
+    
+
+    
+    
+    prevText : 'Previous Page',
+    
+
+    
+    
+    nextText : 'Next Page',
+    
+
+    
+    
+    lastText : 'Last Page',
+    
+
+    
+    
+    refreshText : 'Refresh',
+    
+
+    
+    inputItemWidth : 30,
+
+    
+    getPagingItems: function() {
+        var me = this;
+
+        return [{
+            itemId: 'first',
+            tooltip: me.firstText,
+            overflowText: me.firstText,
+            iconCls: Ext.baseCSSPrefix + 'tbar-page-first',
+            disabled: true,
+            handler: me.moveFirst,
+            scope: me
+        },{
+            itemId: 'prev',
+            tooltip: me.prevText,
+            overflowText: me.prevText,
+            iconCls: Ext.baseCSSPrefix + 'tbar-page-prev',
+            disabled: true,
+            handler: me.movePrevious,
+            scope: me
+        },
+        '-',
+        me.beforePageText,
+        {
+            xtype: 'numberfield',
+            itemId: 'inputItem',
+            name: 'inputItem',
+            cls: Ext.baseCSSPrefix + 'tbar-page-number',
+            allowDecimals: false,
+            minValue: 1,
+            hideTrigger: true,
+            enableKeyEvents: true,
+            keyNavEnabled: false,
+            selectOnFocus: true,
+            submitValue: false,
+            
+            isFormField: false,
+            width: me.inputItemWidth,
+            margins: '-1 2 3 2',
+            listeners: {
+                scope: me,
+                keydown: me.onPagingKeyDown,
+                blur: me.onPagingBlur
+            }
+        },{
+            xtype: 'tbtext',
+            itemId: 'afterTextItem',
+            text: Ext.String.format(me.afterPageText, 1)
+        },
+        '-',
+        {
+            itemId: 'next',
+            tooltip: me.nextText,
+            overflowText: me.nextText,
+            iconCls: Ext.baseCSSPrefix + 'tbar-page-next',
+            disabled: true,
+            handler: me.moveNext,
+            scope: me
+        },{
+            itemId: 'last',
+            tooltip: me.lastText,
+            overflowText: me.lastText,
+            iconCls: Ext.baseCSSPrefix + 'tbar-page-last',
+            disabled: true,
+            handler: me.moveLast,
+            scope: me
+        },
+        '-',
+        {
+            itemId: 'refresh',
+            tooltip: me.refreshText,
+            overflowText: me.refreshText,
+            iconCls: Ext.baseCSSPrefix + 'tbar-loading',
+            handler: me.doRefresh,
+            scope: me
+        }];
+    },
+
+    initComponent : function(){
+        var me = this,
+            pagingItems = me.getPagingItems(),
+            userItems   = me.items || me.buttons || [];
+
+        if (me.prependButtons) {
+            me.items = userItems.concat(pagingItems);
+        } else {
+            me.items = pagingItems.concat(userItems);
+        }
+        delete me.buttons;
+
+        if (me.displayInfo) {
+            me.items.push('->');
+            me.items.push({xtype: 'tbtext', itemId: 'displayItem'});
+        }
+
+        me.callParent();
+
+        me.addEvents(
+            
+            'change',
+
+            
+            'beforechange'
+        );
+        me.on('beforerender', me.onLoad, me, {single: true});
+
+        me.bindStore(me.store || 'ext-empty-store', true);
+    },
+    
+    updateInfo : function(){
+        var me = this,
+            displayItem = me.child('#displayItem'),
+            store = me.store,
+            pageData = me.getPageData(),
+            count, msg;
+
+        if (displayItem) {
+            count = store.getCount();
+            if (count === 0) {
+                msg = me.emptyMsg;
+            } else {
+                msg = Ext.String.format(
+                    me.displayMsg,
+                    pageData.fromRecord,
+                    pageData.toRecord,
+                    pageData.total
+                );
+            }
+            displayItem.setText(msg);
+        }
+    },
+
+    
+    onLoad : function(){
+        var me = this,
+            pageData,
+            currPage,
+            pageCount,
+            afterText,
+            count,
+            isEmpty;
+
+        count = me.store.getCount();
+        isEmpty = count === 0;
+        if (!isEmpty) {
+            pageData = me.getPageData();
+            currPage = pageData.currentPage;
+            pageCount = pageData.pageCount;
+            afterText = Ext.String.format(me.afterPageText, isNaN(pageCount) ? 1 : pageCount);
+        } else {
+            currPage = 0;
+            pageCount = 0;
+            afterText = Ext.String.format(me.afterPageText, 0);
+        }
+
+        Ext.suspendLayouts();
+        me.child('#afterTextItem').setText(afterText);
+        me.child('#inputItem').setDisabled(isEmpty).setValue(currPage);
+        me.child('#first').setDisabled(currPage === 1 || isEmpty);
+        me.child('#prev').setDisabled(currPage === 1  || isEmpty);
+        me.child('#next').setDisabled(currPage === pageCount  || isEmpty);
+        me.child('#last').setDisabled(currPage === pageCount  || isEmpty);
+        me.child('#refresh').enable();
+        me.updateInfo();
+        Ext.resumeLayouts(true);
+
+        if (me.rendered) {
+            me.fireEvent('change', me, pageData);
+        }
+    },
+
+    
+    getPageData : function(){
+        var store = this.store,
+            totalCount = store.getTotalCount();
+
+        return {
+            total : totalCount,
+            currentPage : store.currentPage,
+            pageCount: Math.ceil(totalCount / store.pageSize),
+            fromRecord: ((store.currentPage - 1) * store.pageSize) + 1,
+            toRecord: Math.min(store.currentPage * store.pageSize, totalCount)
+
+        };
+    },
+
+    
+    onLoadError : function(){
+        if (!this.rendered) {
+            return;
+        }
+        this.child('#refresh').enable();
+    },
+
+    
+    readPageFromInput : function(pageData){
+        var v = this.child('#inputItem').getValue(),
+            pageNum = parseInt(v, 10);
+
+        if (!v || isNaN(pageNum)) {
+            this.child('#inputItem').setValue(pageData.currentPage);
+            return false;
+        }
+        return pageNum;
+    },
+
+    onPagingFocus : function(){
+        this.child('#inputItem').select();
+    },
+
+    
+    onPagingBlur : function(e){
+        var curPage = this.getPageData().currentPage;
+        this.child('#inputItem').setValue(curPage);
+    },
+
+    
+    onPagingKeyDown : function(field, e){
+        var me = this,
+            k = e.getKey(),
+            pageData = me.getPageData(),
+            increment = e.shiftKey ? 10 : 1,
+            pageNum;
+
+        if (k == e.RETURN) {
+            e.stopEvent();
+            pageNum = me.readPageFromInput(pageData);
+            if (pageNum !== false) {
+                pageNum = Math.min(Math.max(1, pageNum), pageData.pageCount);
+                if(me.fireEvent('beforechange', me, pageNum) !== false){
+                    me.store.loadPage(pageNum);
+                }
+            }
+        } else if (k == e.HOME || k == e.END) {
+            e.stopEvent();
+            pageNum = k == e.HOME ? 1 : pageData.pageCount;
+            field.setValue(pageNum);
+        } else if (k == e.UP || k == e.PAGE_UP || k == e.DOWN || k == e.PAGE_DOWN) {
+            e.stopEvent();
+            pageNum = me.readPageFromInput(pageData);
+            if (pageNum) {
+                if (k == e.DOWN || k == e.PAGE_DOWN) {
+                    increment *= -1;
+                }
+                pageNum += increment;
+                if (pageNum >= 1 && pageNum <= pageData.pageCount) {
+                    field.setValue(pageNum);
+                }
+            }
+        }
+    },
+
+    
+    beforeLoad : function(){
+        if(this.rendered && this.refresh){
+            this.refresh.disable();
+        }
+    },
+
+    
+    moveFirst : function(){
+        if (this.fireEvent('beforechange', this, 1) !== false){
+            this.store.loadPage(1);
+        }
+    },
+
+    
+    movePrevious : function(){
+        var me = this,
+            prev = me.store.currentPage - 1;
+
+        if (prev > 0) {
+            if (me.fireEvent('beforechange', me, prev) !== false) {
+                me.store.previousPage();
+            }
+        }
+    },
+
+    
+    moveNext : function(){
+        var me = this,
+            total = me.getPageData().pageCount,
+            next = me.store.currentPage + 1;
+
+        if (next <= total) {
+            if (me.fireEvent('beforechange', me, next) !== false) {
+                me.store.nextPage();
+            }
+        }
+    },
+
+    
+    moveLast : function(){
+        var me = this,
+            last = me.getPageData().pageCount;
+
+        if (me.fireEvent('beforechange', me, last) !== false) {
+            me.store.loadPage(last);
+        }
+    },
+
+    
+    doRefresh : function(){
+        var me = this,
+            current = me.store.currentPage;
+
+        if (me.fireEvent('beforechange', me, current) !== false) {
+            me.store.loadPage(current);
+        }
+    },
+    
+    getStoreListeners: function() {
+        return {
+            beforeload: this.beforeLoad,
+            load: this.onLoad,
+            exception: this.onLoadError
+        };
+    },
+
+    
+    unbind : function(store){
+        this.bindStore(null);
+    },
+
+    
+    bind : function(store){
+        this.bindStore(store);
+    },
+
+    
+    onDestroy : function(){
+        this.unbind();
+        this.callParent();
+    }
+});
+
+
+Ext.define('Ext.view.BoundList', {
+    extend: 'Ext.view.View',
+    alias: 'widget.boundlist',
+    alternateClassName: 'Ext.BoundList',
+    requires: ['Ext.layout.component.BoundList', 'Ext.toolbar.Paging'],
+
+    
+    pageSize: 0,
+    
+    
+
+    
+
+    
+    baseCls: Ext.baseCSSPrefix + 'boundlist',
+    itemCls: Ext.baseCSSPrefix + 'boundlist-item',
+    listItemCls: '',
+    shadow: false,
+    trackOver: true,
+    refreshed: 0,
+    
+    
+    deferInitialRefresh: false,
+
+    componentLayout: 'boundlist',
+
+    childEls: [
+        'listEl'
+    ],
+
+    renderTpl: [
+        '<div id="{id}-listEl" class="{baseCls}-list-ct" style="overflow:auto"></div>',
+        '{%',
+            'var me=values.$comp, pagingToolbar=me.pagingToolbar;',
+            'if (pagingToolbar) {',
+                'pagingToolbar.ownerLayout = me.componentLayout;',
+                'Ext.DomHelper.generateMarkup(pagingToolbar.getRenderTree(), out);',
+            '}',
+        '%}',
+        {
+            disableFormats: true
+        }
+    ],
+
+    
+
+    initComponent: function() {
+        var me = this,
+            baseCls = me.baseCls,
+            itemCls = me.itemCls;
+            
+        me.selectedItemCls = baseCls + '-selected';
+        me.overItemCls = baseCls + '-item-over';
+        me.itemSelector = "." + itemCls;
+
+        if (me.floating) {
+            me.addCls(baseCls + '-floating');
+        }
+
+        if (!me.tpl) {
+            
+            
+            me.tpl = new Ext.XTemplate(
+                '<ul><tpl for=".">',
+                    '<li role="option" class="' + itemCls + '">' + me.getInnerTpl(me.displayField) + '</li>',
+                '</tpl></ul>'
+            );
+        } else if (Ext.isString(me.tpl)) {
+            me.tpl = new Ext.XTemplate(me.tpl);
+        }
+
+        if (me.pageSize) {
+            me.pagingToolbar = me.createPagingToolbar();
+        }
+
+        me.callParent();
+    },
+
+    beforeRender: function() {
+        var me = this;
+
+        me.callParent(arguments);
+
+        
+        
+        if (me.up('menu')) {
+            me.addCls(Ext.baseCSSPrefix + 'menu');
+        }
+    },
+
+    
+    getBubbleTarget: function() {
+        return this.pickerField;
+    },
+
+    getRefItems: function() {
+        return this.pagingToolbar ? [ this.pagingToolbar ] : [];
+    },
+
+    createPagingToolbar: function() {
+        return Ext.widget('pagingtoolbar', {
+            id: this.id + '-paging-toolbar',
+            pageSize: this.pageSize,
+            store: this.store,
+            border: false,
+            ownerCt: this,
+            ownerLayout: this.getComponentLayout()
+        });
+    },
+
+    
+    
+    finishRenderChildren: function () {
+        var toolbar = this.pagingToolbar;
+
+        this.callParent(arguments);
+
+        if (toolbar) {
+            toolbar.finishRender();
+        }
+    },
+    
+    refresh: function(){
+        var me = this,
+            toolbar = me.pagingToolbar;
+        
+        me.callParent();
+        
+        
+        if (me.rendered && toolbar && toolbar.rendered && !me.preserveScrollOnRefresh) {
+            me.el.appendChild(toolbar.el);
+        }  
+    },
+
+    bindStore : function(store, initial) {
+        var toolbar = this.pagingToolbar;
+            
+        this.callParent(arguments);
+        if (toolbar) {
+            toolbar.bindStore(this.store, initial);
+        }
+    },
+
+    getTargetEl: function() {
+        return this.listEl || this.el;
+    },
+
+    
+    getInnerTpl: function(displayField) {
+        return '{' + displayField + '}';
+    },
+
+    onDestroy: function() {
+        Ext.destroyMembers(this, 'pagingToolbar', 'listEl');
+        this.callParent();
+    }
+});
+
+
+Ext.define('Ext.view.BoundListKeyNav', {
+    extend: 'Ext.util.KeyNav',
+    requires: 'Ext.view.BoundList',
+
+    
+
+    constructor: function(el, config) {
+        var me = this;
+        me.boundList = config.boundList;
+        me.callParent([el, Ext.apply({}, config, me.defaultHandlers)]);
+    },
+
+    defaultHandlers: {
+        up: function() {
+            var me = this,
+                boundList = me.boundList,
+                allItems = boundList.all,
+                oldItem = boundList.highlightedItem,
+                oldItemIdx = oldItem ? boundList.indexOf(oldItem) : -1,
+                newItemIdx = oldItemIdx > 0 ? oldItemIdx - 1 : allItems.getCount() - 1; 
+            me.highlightAt(newItemIdx);
+        },
+
+        down: function() {
+            var me = this,
+                boundList = me.boundList,
+                allItems = boundList.all,
+                oldItem = boundList.highlightedItem,
+                oldItemIdx = oldItem ? boundList.indexOf(oldItem) : -1,
+                newItemIdx = oldItemIdx < allItems.getCount() - 1 ? oldItemIdx + 1 : 0; 
+            me.highlightAt(newItemIdx);
+        },
+
+        pageup: function() {
+            
+        },
+
+        pagedown: function() {
+            
+        },
+
+        home: function() {
+            this.highlightAt(0);
+        },
+
+        end: function() {
+            var me = this;
+            me.highlightAt(me.boundList.all.getCount() - 1);
+        },
+
+        enter: function(e) {
+            this.selectHighlighted(e);
+        }
+    },
+
+    
+    highlightAt: function(index) {
+        var boundList = this.boundList,
+            item = boundList.all.item(index);
+        if (item) {
+            item = item.dom;
+            boundList.highlightItem(item);
+            boundList.getTargetEl().scrollChildIntoView(item, false);
+        }
+    },
+
+    
+    selectHighlighted: function(e) {
+        var me = this,
+            boundList = me.boundList,
+            highlighted = boundList.highlightedItem,
+            selModel = boundList.getSelectionModel();
+        if (highlighted) {
+            selModel.selectWithEvent(boundList.getRecord(highlighted), e);
+        }
+    }
+
+});
+
+
+Ext.define('Ext.form.field.ComboBox', {
+    extend:'Ext.form.field.Picker',
+    requires: ['Ext.util.DelayedTask', 'Ext.EventObject', 'Ext.view.BoundList', 'Ext.view.BoundListKeyNav', 'Ext.data.StoreManager', 'Ext.layout.component.field.ComboBox'],
+    alternateClassName: 'Ext.form.ComboBox',
+    alias: ['widget.combobox', 'widget.combo'],
+    mixins: {
+        bindable: 'Ext.util.Bindable'    
+    },
+
+    componentLayout: 'combobox',
+
+    
+    triggerCls: Ext.baseCSSPrefix + 'form-arrow-trigger',
+    
+    
+    hiddenName: '',
+    
+    
+
+    
+    hiddenDataCls: Ext.baseCSSPrefix + 'hide-display ' + Ext.baseCSSPrefix + 'form-data-hidden',
+
+    
+    fieldSubTpl: [
+        '<div class="{hiddenDataCls}" role="presentation"></div>',
+        '<input id="{id}" type="{type}" {inputAttrTpl} class="{fieldCls} {typeCls}" autocomplete="off"',
+            '<tpl if="value"> value="{[Ext.util.Format.htmlEncode(values.value)]}"</tpl>',
+            '<tpl if="name"> name="{name}"</tpl>',
+            '<tpl if="placeholder"> placeholder="{placeholder}"</tpl>',
+            '<tpl if="size"> size="{size}"</tpl>',
+            '<tpl if="maxLength !== undefined"> maxlength="{maxLength}"</tpl>',
+            '<tpl if="readOnly"> readonly="readonly"</tpl>',
+            '<tpl if="disabled"> disabled="disabled"</tpl>',
+            '<tpl if="tabIdx"> tabIndex="{tabIdx}"</tpl>',
+            '<tpl if="fieldStyle"> style="{fieldStyle}"</tpl>',
+            '/>',
+        {
+            compiled: true,
+            disableFormats: true
+        }
+    ],
+
+    getSubTplData: function(){
+        var me = this;
+        Ext.applyIf(me.subTplData, {
+            hiddenDataCls: me.hiddenDataCls
+        });
+        return me.callParent(arguments);
+    },
+
+    afterRender: function(){
+        var me = this;
+        me.callParent(arguments);
+        me.setHiddenValue(me.value);
+    },
+
+    
+
+    
+    multiSelect: false,
+
+    
+    
+    delimiter: ', ',
+    
+
+    
+    displayField: 'text',
+
+    
+
+    
+    triggerAction: 'all',
+
+    
+    allQuery: '',
+
+    
+    queryParam: 'query',
+
+    
+    queryMode: 'remote',
+
+    
+    queryCaching: true,
+
+    
+    pageSize: 0,
+
+    
+
+    
+
+    
+    autoSelect: true,
+
+    
+    typeAhead: false,
+
+    
+    typeAheadDelay: 250,
+
+    
+    selectOnTab: true,
+
+    
+    forceSelection: false,
+
+    
+    growToLongestValue: true,
+
+    
+
+    
+
+    
+    defaultListConfig: {
+        loadingHeight: 70,
+        minWidth: 70,
+        maxHeight: 300,
+        shadow: 'sides'
+    },
+
+    
+
+    
+
+    
+    ignoreSelection: 0,
+
+    
+    removingRecords: null,
+
+    
+    resizeComboToGrow: function () {
+        var me = this;
+        return me.grow && me.growToLongestValue;
+    },
+
+    initComponent: function() {
+        var me = this,
+            isDefined = Ext.isDefined,
+            store = me.store,
+            transform = me.transform,
+            transformSelect, isLocalMode;
+
+        Ext.applyIf(me.renderSelectors, {
+            hiddenDataEl: '.' + me.hiddenDataCls.split(' ').join('.')
+        });
+        
+
+        this.addEvents(
+            
+            'beforequery',
+
+            
+            'select',
+
+            
+            'beforeselect',
+
+            
+            'beforedeselect'
+        );
+
+        
+        if (transform) {
+            transformSelect = Ext.getDom(transform);
+            if (transformSelect) {
+                if (!me.store) {
+                    store = Ext.Array.map(Ext.Array.from(transformSelect.options), function(option){
+                        return [option.value, option.text];
+                    });
+                }
+                if (!me.name) {
+                    me.name = transformSelect.name;
+                }
+                if (!('value' in me)) {
+                    me.value = transformSelect.value;
+                }
+            }
+        }
+
+        me.bindStore(store || 'ext-empty-store', true);
+        store = me.store;
+        if (store.autoCreated) {
+            me.queryMode = 'local';
+            me.valueField = me.displayField = 'field1';
+            if (!store.expanded) {
+                me.displayField = 'field2';
+            }
+        }
+
+
+        if (!isDefined(me.valueField)) {
+            me.valueField = me.displayField;
+        }
+
+        isLocalMode = me.queryMode === 'local';
+        if (!isDefined(me.queryDelay)) {
+            me.queryDelay = isLocalMode ? 10 : 500;
+        }
+        if (!isDefined(me.minChars)) {
+            me.minChars = isLocalMode ? 0 : 4;
+        }
+
+        if (!me.displayTpl) {
+            me.displayTpl = new Ext.XTemplate(
+                '<tpl for=".">' +
+                    '{[typeof values === "string" ? values : values["' + me.displayField + '"]]}' +
+                    '<tpl if="xindex < xcount">' + me.delimiter + '</tpl>' +
+                '</tpl>'
+            );
+        } else if (Ext.isString(me.displayTpl)) {
+            me.displayTpl = new Ext.XTemplate(me.displayTpl);
+        }
+
+        me.callParent();
+
+        me.doQueryTask = new Ext.util.DelayedTask(me.doRawQuery, me);
+
+        
+        if (me.store.getCount() > 0) {
+            me.setValue(me.value);
+        }
+
+        
+        if (transformSelect) {
+            me.render(transformSelect.parentNode, transformSelect);
+            Ext.removeNode(transformSelect);
+            delete me.renderTo;
+        }
+    },
+
+    
+    getStore : function(){
+        return this.store;
+    },
+
+    beforeBlur: function() {
+        this.doQueryTask.cancel();
+        this.assertValue();
+    },
+
+    
+    assertValue: function() {
+        var me = this,
+            value = me.getRawValue(),
+            rec;
+
+        if (me.forceSelection) {
+            if (me.multiSelect) {
+                
+                
+                if (value !== me.getDisplayValue()) {
+                    me.setValue(me.lastSelection);
+                }
+            } else {
+                
+                
+                rec = me.findRecordByDisplay(value);
+                if (rec) {
+                    me.select(rec);
+                } else {
+                    me.setValue(me.lastSelection);
+                }
+            }
+        }
+        me.collapse();
+    },
+
+    onTypeAhead: function() {
+        var me = this,
+            displayField = me.displayField,
+            record = me.store.findRecord(displayField, me.getRawValue()),
+            boundList = me.getPicker(),
+            newValue, len, selStart;
+
+        if (record) {
+            newValue = record.get(displayField);
+            len = newValue.length;
+            selStart = me.getRawValue().length;
+
+            boundList.highlightItem(boundList.getNode(record));
+
+            if (selStart !== 0 && selStart !== len) {
+                me.setRawValue(newValue);
+                me.selectText(selStart, newValue.length);
+            }
+        }
+    },
+
+    
+    
+    resetToDefault: Ext.emptyFn,
+    
+    beforeReset: function() {
+        this.callParent();
+        this.clearFilter();    
+    },
+    
+    onUnbindStore: function(store) {
+        var picker = this.picker;
+        if (!store && picker) {
+            picker.bindStore(null);
+        }
+        this.clearFilter();
+    },
+    
+    onBindStore: function(store, initial) {
+        var picker = this.picker;
+        if (!initial) {
+            this.resetToDefault();
+        }
+        if (picker) {
+            picker.bindStore(store);
+        }
+    },
+    
+    getStoreListeners: function() {
+        var me = this;
+        
+        return {
+            beforeload: me.onBeforeLoad,
+            clear: me.onClear,
+            datachanged: me.onDataChanged,
+            load: me.onLoad,
+            exception: me.onException,
+            remove: me.onRemove
+        }; 
+    },
+    
+    onBeforeLoad: function(){
+        
+        
+        
+        ++this.ignoreSelection;    
+    },
+    
+    onDataChanged: function() {
+        var me = this;
+
+        if (me.resizeComboToGrow()) {
+            me.updateLayout();
+        }
+    },
+
+    onClear: function() {
+        var me = this;
+
+        if (me.resizeComboToGrow()) {
+            me.removingRecords = true;
+            me.onDataChanged();
+        }
+    },
+
+    onRemove: function() {
+        var me = this;
+
+        if (me.resizeComboToGrow()) {
+            me.removingRecords = true;
+        }
+    },
+
+    onException: function(){
+        if (this.ignoreSelection > 0) {
+            --this.ignoreSelection;
+        }
+        this.collapse();    
+    },
+
+    onLoad: function() {
+        var me = this,
+            value = me.value;
+
+        if (me.ignoreSelection > 0) {
+            --me.ignoreSelection;
+        }
+        
+        if (me.rawQuery) {
+            me.rawQuery = false;
+            me.syncSelection();
+            if (me.picker && !me.picker.getSelectionModel().hasSelection()) {
+                me.doAutoSelect();
+            }
+        }
+        
+        else {
+            
+            if (me.value || me.value === 0) {
+                me.setValue(me.value);
+            } else {
+                
+                
+                if (me.store.getCount()) {
+                    me.doAutoSelect();
+                } else {
+                    
+                    me.setValue(me.value);
+                }
+            }
+        }
+    },
+
+    
+    doRawQuery: function() {
+        this.doQuery(this.getRawValue(), false, true);
+    },
+
+    
+    doQuery: function(queryString, forceAll, rawQuery) {
+        queryString = queryString || '';
+
+        
+        
+        var me = this,
+            qe = {
+                query: queryString,
+                forceAll: forceAll,
+                combo: me,
+                cancel: false
+            },
+            store = me.store,
+            isLocalMode = me.queryMode === 'local',
+            needsRefresh;
+
+        if (me.fireEvent('beforequery', qe) === false || qe.cancel) {
+            return false;
+        }
+
+        
+        queryString = qe.query;
+        forceAll = qe.forceAll;
+
+        
+        if (forceAll || (queryString.length >= me.minChars)) {
+            
+            me.expand();
+
+            
+            if (!me.queryCaching || me.lastQuery !== queryString) {
+                me.lastQuery = queryString;
+
+                if (isLocalMode) {
+                    
+                    store.suspendEvents();
+                    needsRefresh = me.clearFilter();
+                    if (queryString || !forceAll) {
+                        me.activeFilter = new Ext.util.Filter({
+                            root: 'data',
+                            property: me.displayField,
+                            value: queryString
+                        });
+                        store.filter(me.activeFilter);
+                        needsRefresh = true;
+                    } else {
+                        delete me.activeFilter;
+                    }
+                    store.resumeEvents();
+                    if (me.rendered && needsRefresh) {
+                        me.getPicker().refresh();
+                    }
+                } else {
+                    
+                    me.rawQuery = rawQuery;
+
+                    
+                    
+                    if (me.pageSize) {
+                        
+                        me.loadPage(1);
+                    } else {
+                        store.load({
+                            params: me.getParams(queryString)
+                        });
+                    }
+                }
+            }
+
+            
+            if (me.getRawValue() !== me.getDisplayValue()) {
+                me.ignoreSelection++;
+                me.picker.getSelectionModel().deselectAll();
+                me.ignoreSelection--;
+            }
+
+            if (isLocalMode) {
+                me.doAutoSelect();
+            }
+            if (me.typeAhead) {
+                me.doTypeAhead();
+            }
+        }
+        return true;
+    },
+    
+    
+    clearFilter: function() {
+        var store = this.store,
+            filter = this.activeFilter,
+            filters = store.filters,
+            remaining;
+            
+        if (filter) {
+            if (filters.getCount() > 1) {
+                
+                filters.remove(filter);
+                remaining = filters.getRange();
+            }
+            store.clearFilter(true);
+            if (remaining) {
+                store.filter(remaining);
+            }
+        }
+        return !!filter;
+    },
+
+    loadPage: function(pageNum){
+        this.store.loadPage(pageNum, {
+            params: this.getParams(this.lastQuery)
+        });
+    },
+
+    onPageChange: function(toolbar, newPage){
+        
+        this.loadPage(newPage);
+        return false;
+    },
+
+    
+    getParams: function(queryString) {
+        var params = {},
+            param = this.queryParam;
+
+        if (param) {
+            params[param] = queryString;
+        }
+        return params;
+    },
+
+    
+    doAutoSelect: function() {
+        var me = this,
+            picker = me.picker,
+            lastSelected, itemNode;
+        if (picker && me.autoSelect && me.store.getCount() > 0) {
+            
+            lastSelected = picker.getSelectionModel().lastSelected;
+            itemNode = picker.getNode(lastSelected || 0);
+            if (itemNode) {
+                picker.highlightItem(itemNode);
+                picker.listEl.scrollChildIntoView(itemNode, false);
+            }
+        }
+    },
+
+    doTypeAhead: function() {
+        if (!this.typeAheadTask) {
+            this.typeAheadTask = new Ext.util.DelayedTask(this.onTypeAhead, this);
+        }
+        if (this.lastKey != Ext.EventObject.BACKSPACE && this.lastKey != Ext.EventObject.DELETE) {
+            this.typeAheadTask.delay(this.typeAheadDelay);
+        }
+    },
+
+    onTriggerClick: function() {
+        var me = this;
+        if (!me.readOnly && !me.disabled) {
+            if (me.isExpanded) {
+                me.collapse();
+            } else {
+                me.onFocus({});
+                if (me.triggerAction === 'all') {
+                    me.doQuery(me.allQuery, true);
+                } else {
+                    me.doQuery(me.getRawValue(), false, true);
+                }
+            }
+            me.inputEl.focus();
+        }
+    },
+
+
+    
+    onKeyUp: function(e, t) {
+        var me = this,
+            key = e.getKey();
+
+        if (!me.readOnly && !me.disabled && me.editable) {
+            me.lastKey = key;
+            
+            
+
+            
+            if (!e.isSpecialKey() || key == e.BACKSPACE || key == e.DELETE) {
+                me.doQueryTask.delay(me.queryDelay);
+            }
+        }
+
+        if (me.enableKeyEvents) {
+            me.callParent(arguments);
+        }
+    },
+
+    initEvents: function() {
+        var me = this;
+        me.callParent();
+
+        
+        if (!me.enableKeyEvents) {
+            me.mon(me.inputEl, 'keyup', me.onKeyUp, me);
+        }
+    },
+
+    onDestroy: function() {
+        this.bindStore(null);
+        this.callParent();
+    },
+
+    
+    
+    onAdded: function() {
+        var me = this;
+        me.callParent(arguments);
+        if (me.picker) {
+            me.picker.ownerCt = me.up('[floating]');
+            me.picker.registerWithOwnerCt();
+        }
+    },
+
+    createPicker: function() {
+        var me = this,
+            picker,
+            pickerCfg = Ext.apply({
+                xtype: 'boundlist',
+                pickerField: me,
+                selModel: {
+                    mode: me.multiSelect ? 'SIMPLE' : 'SINGLE'
+                },
+                floating: true,
+                hidden: true,
+                store: me.store,
+                displayField: me.displayField,
+                focusOnToFront: false,
+                pageSize: me.pageSize,
+                tpl: me.tpl
+            }, me.listConfig, me.defaultListConfig);
+
+        picker = me.picker = Ext.widget(pickerCfg);
+        if (me.pageSize) {
+            picker.pagingToolbar.on('beforechange', me.onPageChange, me);
+        }
+
+        me.mon(picker, {
+            itemclick: me.onItemClick,
+            refresh: me.onListRefresh,
+            scope: me
+        });
+
+        me.mon(picker.getSelectionModel(), {
+            beforeselect: me.onBeforeSelect,
+            beforedeselect: me.onBeforeDeselect,
+            selectionchange: me.onListSelectionChange,
+            scope: me
+        });
+
+        return picker;
+    },
+
+    alignPicker: function(){
+        var me = this,
+            picker = me.getPicker(),
+            heightAbove = me.getPosition()[1] - Ext.getBody().getScroll().top,
+            heightBelow = Ext.Element.getViewHeight() - heightAbove - me.getHeight(),
+            space = Math.max(heightAbove, heightBelow);
+
+        
+        if (picker.height) {
+            delete picker.height;
+            picker.updateLayout();
+        }
+        
+        if (picker.getHeight() > space - 5) {
+            picker.setHeight(space - 5); 
+        }
+        me.callParent();
+    },
+
+    onListRefresh: function() {
+        this.alignPicker();
+        this.syncSelection();
+    },
+
+    onItemClick: function(picker, record){
+        
+        var me = this,
+            selection = me.picker.getSelectionModel().getSelection(),
+            valueField = me.valueField;
+
+        if (!me.multiSelect && selection.length) {
+            if (record.get(valueField) === selection[0].get(valueField)) {
+                
+                me.displayTplData = [record.data];
+                me.setRawValue(me.getDisplayValue());
+                me.collapse();
+            }
+        }
+    },
+
+    onBeforeSelect: function(list, record) {
+        return this.fireEvent('beforeselect', this, record, record.index);
+    },
+
+    onBeforeDeselect: function(list, record) {
+        return this.fireEvent('beforedeselect', this, record, record.index);
+    },
+
+    onListSelectionChange: function(list, selectedRecords) {
+        var me = this,
+            isMulti = me.multiSelect,
+            hasRecords = selectedRecords.length > 0;
+        
+        
+        if (!me.ignoreSelection && me.isExpanded) {
+            if (!isMulti) {
+                Ext.defer(me.collapse, 1, me);
+            }
+            
+            if (isMulti || hasRecords) {
+                me.setValue(selectedRecords, false);
+            }
+            if (hasRecords) {
+                me.fireEvent('select', me, selectedRecords);
+            }
+            me.inputEl.focus();
+        }
+    },
+
+    
+    onExpand: function() {
+        var me = this,
+            keyNav = me.listKeyNav,
+            selectOnTab = me.selectOnTab,
+            picker = me.getPicker();
+
+        
+        if (keyNav) {
+            keyNav.enable();
+        } else {
+            keyNav = me.listKeyNav = new Ext.view.BoundListKeyNav(this.inputEl, {
+                boundList: picker,
+                forceKeyDown: true,
+                tab: function(e) {
+                    if (selectOnTab) {
+                        this.selectHighlighted(e);
+                        me.triggerBlur();
+                    }
+                    
+                    return true;
+                }
+            });
+        }
+
+        
+        if (selectOnTab) {
+            me.ignoreMonitorTab = true;
+        }
+
+        Ext.defer(keyNav.enable, 1, keyNav); 
+        me.inputEl.focus();
+    },
+
+    
+    onCollapse: function() {
+        var me = this,
+            keyNav = me.listKeyNav;
+        if (keyNav) {
+            keyNav.disable();
+            me.ignoreMonitorTab = false;
+        }
+    },
+
+    
+    select: function(r) {
+        this.setValue(r, true);
+    },
+
+    
+    findRecord: function(field, value) {
+        var ds = this.store,
+            idx = ds.findExact(field, value);
+        return idx !== -1 ? ds.getAt(idx) : false;
+    },
+
+    
+    findRecordByValue: function(value) {
+        return this.findRecord(this.valueField, value);
+    },
+
+    
+    findRecordByDisplay: function(value) {
+        return this.findRecord(this.displayField, value);
+    },
+
+    
+    setValue: function(value, doSelect) {
+        var me = this,
+            valueNotFoundText = me.valueNotFoundText,
+            inputEl = me.inputEl,
+            i, len, record,
+            dataObj,
+            matchedRecords = [],
+            displayTplData = [],
+            processedValue = [];
+
+        if (me.store.loading) {
+            
+            me.value = value;
+            me.setHiddenValue(me.value);
+            return me;
+        }
+
+        
+        value = Ext.Array.from(value);
+
+        
+        for (i = 0, len = value.length; i < len; i++) {
+            record = value[i];
+            if (!record || !record.isModel) {
+                record = me.findRecordByValue(record);
+            }
+            
+            if (record) {
+                matchedRecords.push(record);
+                displayTplData.push(record.data);
+                processedValue.push(record.get(me.valueField));
+            }
+            
+            
+            else {
+                
+                
+                if (!me.forceSelection) {
+                    processedValue.push(value[i]);
+                    dataObj = {};
+                    dataObj[me.displayField] = value[i];
+                    displayTplData.push(dataObj);
+                    
+                }
+                
+                else if (Ext.isDefined(valueNotFoundText)) {
+                    displayTplData.push(valueNotFoundText);
+                }
+            }
+        }
+
+        
+        me.setHiddenValue(processedValue);
+        me.value = me.multiSelect ? processedValue : processedValue[0];
+        if (!Ext.isDefined(me.value)) {
+            me.value = null;
+        }
+        me.displayTplData = displayTplData; 
+        me.lastSelection = me.valueModels = matchedRecords;
+
+        if (inputEl && me.emptyText && !Ext.isEmpty(value)) {
+            inputEl.removeCls(me.emptyCls);
+        }
+
+        
+        me.setRawValue(me.getDisplayValue());
+        me.checkChange();
+
+        if (doSelect !== false) {
+            me.syncSelection();
+        }
+        me.applyEmptyText();
+
+        return me;
+    },
+
+    
+    setHiddenValue: function(values){
+        var me = this,
+            name = me.hiddenName, 
+            i,
+            dom, childNodes, input, valueCount, childrenCount;
+            
+        if (!me.hiddenDataEl || !name) {
+            return;
+        }
+        values = Ext.Array.from(values);
+        dom = me.hiddenDataEl.dom;
+        childNodes = dom.childNodes;
+        input = childNodes[0];
+        valueCount = values.length;
+        childrenCount = childNodes.length;
+        
+        if (!input && valueCount > 0) {
+            me.hiddenDataEl.update(Ext.DomHelper.markup({
+                tag: 'input', 
+                type: 'hidden', 
+                name: name
+            }));
+            childrenCount = 1;
+            input = dom.firstChild;
+        }
+        while (childrenCount > valueCount) {
+            dom.removeChild(childNodes[0]);
+            -- childrenCount;
+        }
+        while (childrenCount < valueCount) {
+            dom.appendChild(input.cloneNode(true));
+            ++ childrenCount;
+        }
+        for (i = 0; i < valueCount; i++) {
+            childNodes[i].value = values[i];
+        }
+    },
+
+    
+    getDisplayValue: function() {
+        return this.displayTpl.apply(this.displayTplData);
+    },
+
+    getValue: function() {
+        
+        
+        
+        var me = this,
+            picker = me.picker,
+            rawValue = me.getRawValue(), 
+            value = me.value; 
+
+        if (me.getDisplayValue() !== rawValue) {
+            value = rawValue;
+            me.value = me.displayTplData = me.valueModels = null;
+            if (picker) {
+                me.ignoreSelection++;
+                picker.getSelectionModel().deselectAll();
+                me.ignoreSelection--;
+            }
+        }
+
+        return value;
+    },
+
+    getSubmitValue: function() {
+        return this.getValue();
+    },
+
+    isEqual: function(v1, v2) {
+        var fromArray = Ext.Array.from,
+            i, len;
+
+        v1 = fromArray(v1);
+        v2 = fromArray(v2);
+        len = v1.length;
+
+        if (len !== v2.length) {
+            return false;
+        }
+
+        for(i = 0; i < len; i++) {
+            if (v2[i] !== v1[i]) {
+                return false;
+            }
+        }
+
+        return true;
+    },
+
+    
+    clearValue: function() {
+        this.setValue([]);
+    },
+
+    
+    syncSelection: function() {
+        var me = this,
+            picker = me.picker,
+            selection, selModel,
+            values = me.valueModels || [],
+            vLen  = values.length, v, value;
+
+        if (picker) {
+            
+            selection = [];
+            for (v = 0; v < vLen; v++) {
+                value = values[v];
+
+                if (value && value.isModel && me.store.indexOf(value) >= 0) {
+                    selection.push(value);
+                }
+            }
+
+            
+            me.ignoreSelection++;
+            selModel = picker.getSelectionModel();
+            selModel.deselectAll();
+            if (selection.length) {
+                selModel.select(selection);
+            }
+            me.ignoreSelection--;
+        }
+    },
+    
+    onEditorTab: function(e){
+        var keyNav = this.listKeyNav;
+        
+        if (this.selectOnTab && keyNav) {
+            keyNav.selectHighlighted(e);
+        }
+    }
+});
+
+
+Ext.define('Ext.picker.Month', {
+    extend: 'Ext.Component',
+    requires: [
+        'Ext.XTemplate', 
+        'Ext.util.ClickRepeater', 
+        'Ext.Date', 
+        'Ext.button.Button'
+    ],
+    alias: 'widget.monthpicker',
+    alternateClassName: 'Ext.MonthPicker',
+
+    childEls: [
+        'bodyEl', 'prevEl', 'nextEl', 'buttonsEl', 'monthEl', 'yearEl'
+    ],
+
+    renderTpl: [
+        '<div id="{id}-bodyEl" class="{baseCls}-body">',
+          '<div id="{id}-monthEl" class="{baseCls}-months">',
+              '<tpl for="months">',
+                  '<div class="{parent.baseCls}-item {parent.baseCls}-month"><a style="{parent.monthStyle}" href="#" hidefocus="on">{.}</a></div>',
+              '</tpl>',
+          '</div>',
+          '<div id="{id}-yearEl" class="{baseCls}-years">',
+              '<div class="{baseCls}-yearnav">',
+                  '<button id="{id}-prevEl" class="{baseCls}-yearnav-prev"></button>',
+                  '<button id="{id}-nextEl" class="{baseCls}-yearnav-next"></button>',
+              '</div>',
+              '<tpl for="years">',
+                  '<div class="{parent.baseCls}-item {parent.baseCls}-year"><a href="#" hidefocus="on">{.}</a></div>',
+              '</tpl>',
+          '</div>',
+          '<div class="' + Ext.baseCSSPrefix + 'clear"></div>',
+        '</div>',
+        '<tpl if="showButtons">',
+            '<div id="{id}-buttonsEl" class="{baseCls}-buttons">{%',
+                'var me=values.$comp, okBtn=me.okBtn, cancelBtn=me.cancelBtn;',
+                'okBtn.ownerLayout = cancelBtn.ownerLayout = me.componentLayout;',
+                'okBtn.ownerCt = cancelBtn.ownerCt = me;',
+                'Ext.DomHelper.generateMarkup(okBtn.getRenderTree(), out);',
+                'Ext.DomHelper.generateMarkup(cancelBtn.getRenderTree(), out);',
+            '%}</div>',
+        '</tpl>'
+    ],
+
+    
+    
+    okText: 'OK',
+    
+
+    
+    
+    cancelText: 'Cancel',
+    
+
+    
+    baseCls: Ext.baseCSSPrefix + 'monthpicker',
+
+    
+    showButtons: true,
+
+    
+
+    
+    
+    
+    width: 178,
+    measureWidth: 35,
+    measureMaxHeight: 20,
+
+    
+    smallCls: Ext.baseCSSPrefix + 'monthpicker-small',
+
+    
+    totalYears: 10,
+    yearOffset: 5, 
+    monthOffset: 6, 
+
+    
+    initComponent: function(){
+        var me = this;
+
+        me.selectedCls = me.baseCls + '-selected';
+        me.addEvents(
+            
+            'cancelclick',
+
+            
+            'monthclick',
+
+            
+            'monthdblclick',
+
+            
+            'okclick',
+
+            
+            'select',
+
+            
+            'yearclick',
+
+            
+            'yeardblclick'
+        );
+        if (me.small) {
+            me.addCls(me.smallCls);
+        }
+        me.setValue(me.value);
+        me.activeYear = me.getYear(new Date().getFullYear() - 4, -4);
+
+        if (me.showButtons) {
+            me.okBtn = new Ext.button.Button({
+                text: me.okText,
+                handler: me.onOkClick,
+                scope: me
+            });
+            me.cancelBtn = new Ext.button.Button({
+                text: me.cancelText,
+                handler: me.onCancelClick,
+                scope: me
+            });
+        }
+
+        this.callParent();
+    },
+
+    
+    beforeRender: function(){
+        var me = this,
+            i = 0,
+            months = [],
+            shortName = Ext.Date.getShortMonthName,
+            monthLen = me.monthOffset,
+            margin = me.monthMargin,
+            style = '';
+
+        me.callParent();
+
+        for (; i < monthLen; ++i) {
+            months.push(shortName(i), shortName(i + monthLen));
+        }
+        
+        if (Ext.isDefined(margin)) {
+            style = 'margin: 0 ' + margin + 'px;';
+        }
+
+        Ext.apply(me.renderData, {
+            months: months,
+            years: me.getYears(),
+            showButtons: me.showButtons,
+            monthStyle: style
+        });
+    },
+
+    
+    afterRender: function(){
+        var me = this,
+            body = me.bodyEl,
+            buttonsEl = me.buttonsEl;
+
+        me.callParent();
+
+        me.mon(body, 'click', me.onBodyClick, me);
+        me.mon(body, 'dblclick', me.onBodyClick, me);
+
+        
+        me.years = body.select('.' + me.baseCls + '-year a');
+        me.months = body.select('.' + me.baseCls + '-month a');
+
+        me.backRepeater = new Ext.util.ClickRepeater(me.prevEl, {
+            handler: Ext.Function.bind(me.adjustYear, me, [-me.totalYears])
+        });
+
+        me.prevEl.addClsOnOver(me.baseCls + '-yearnav-prev-over');
+        me.nextRepeater = new Ext.util.ClickRepeater(me.nextEl, {
+            handler: Ext.Function.bind(me.adjustYear, me, [me.totalYears])
+        });
+        me.nextEl.addClsOnOver(me.baseCls + '-yearnav-next-over');
+        me.updateBody();
+        
+        if (!Ext.isDefined(me.monthMargin)) {
+            Ext.picker.Month.prototype.monthMargin = me.calculateMonthMargin();
+        }
+    },
+    
+    calculateMonthMargin: function(){
+        
+        
+        
+        
+        var me = this,
+            monthEl = me.monthEl,
+            months = me.months,
+            first = months.first(),
+            itemMargin = first.getMargin('l');
+            
+        while (itemMargin && me.getLargest() > me.measureMaxHeight) {
+            --itemMargin;
+            months.setStyle('margin', '0 ' + itemMargin + 'px');
+        }
+        return itemMargin;
+    },
+    
+    getLargest: function(months){
+        var largest = 0;
+        this.months.each(function(item){
+            var h = item.getHeight();
+            if (h > largest) {
+                largest = h;
+            }
+        });
+        return largest;
+        
+    },
+
+    
+    setValue: function(value){
+        var me = this,
+            active = me.activeYear,
+            offset = me.monthOffset,
+            year,
+            index;
+
+        if (!value) {
+            me.value = [null, null];
+        } else if (Ext.isDate(value)) {
+            me.value = [value.getMonth(), value.getFullYear()];
+        } else {
+            me.value = [value[0], value[1]];
+        }
+
+        if (me.rendered) {
+            year = me.value[1];
+            if (year !== null) {
+                if ((year < active || year > active + me.yearOffset)) {
+                    me.activeYear = year - me.yearOffset + 1;
+                }
+            }
+            me.updateBody();
+        }
+
+        return me;
+    },
+
+    
+    getValue: function(){
+        return this.value;
+    },
+
+    
+    hasSelection: function(){
+        var value = this.value;
+        return value[0] !== null && value[1] !== null;
+    },
+
+    
+    getYears: function(){
+        var me = this,
+            offset = me.yearOffset,
+            start = me.activeYear, 
+            end = start + offset,
+            i = start,
+            years = [];
+
+        for (; i < end; ++i) {
+            years.push(i, i + offset);
+        }
+
+        return years;
+    },
+
+    
+    updateBody: function(){
+        var me = this,
+            years = me.years,
+            months = me.months,
+            yearNumbers = me.getYears(),
+            cls = me.selectedCls,
+            value = me.getYear(null),
+            month = me.value[0],
+            monthOffset = me.monthOffset,
+            year,
+            yearItems, y, yLen, el;
+
+        if (me.rendered) {
+            years.removeCls(cls);
+            months.removeCls(cls);
+
+            yearItems = years.elements;
+            yLen      = yearItems.length;
+
+            for (y = 0; y < yLen; y++) {
+                el = Ext.fly(yearItems[y]);
+
+                year = yearNumbers[y];
+                el.dom.innerHTML = year;
+                if (year == value) {
+                    el.dom.className = cls;
+                }
+            }
+            if (month !== null) {
+                if (month < monthOffset) {
+                    month = month * 2;
+                } else {
+                    month = (month - monthOffset) * 2 + 1;
+                }
+                months.item(month).addCls(cls);
+            }
+        }
+    },
+
+    
+    getYear: function(defaultValue, offset) {
+        var year = this.value[1];
+        offset = offset || 0;
+        return year === null ? defaultValue : year + offset;
+    },
+
+    
+    onBodyClick: function(e, t) {
+        var me = this,
+            isDouble = e.type == 'dblclick';
+
+        if (e.getTarget('.' + me.baseCls + '-month')) {
+            e.stopEvent();
+            me.onMonthClick(t, isDouble);
+        } else if (e.getTarget('.' + me.baseCls + '-year')) {
+            e.stopEvent();
+            me.onYearClick(t, isDouble);
+        }
+    },
+
+    
+    adjustYear: function(offset){
+        if (typeof offset != 'number') {
+            offset = this.totalYears;
+        }
+        this.activeYear += offset;
+        this.updateBody();
+    },
+
+    
+    onOkClick: function(){
+        this.fireEvent('okclick', this, this.value);
+    },
+
+    
+    onCancelClick: function(){
+        this.fireEvent('cancelclick', this);
+    },
+
+    
+    onMonthClick: function(target, isDouble){
+        var me = this;
+        me.value[0] = me.resolveOffset(me.months.indexOf(target), me.monthOffset);
+        me.updateBody();
+        me.fireEvent('month' + (isDouble ? 'dbl' : '') + 'click', me, me.value);
+        me.fireEvent('select', me, me.value);
+    },
+
+    
+    onYearClick: function(target, isDouble){
+        var me = this;
+        me.value[1] = me.activeYear + me.resolveOffset(me.years.indexOf(target), me.yearOffset);
+        me.updateBody();
+        me.fireEvent('year' + (isDouble ? 'dbl' : '') + 'click', me, me.value);
+        me.fireEvent('select', me, me.value);
+
+    },
+
+    
+    resolveOffset: function(index, offset){
+        if (index % 2 === 0) {
+            return (index / 2);
+        } else {
+            return offset + Math.floor(index / 2);
+        }
+    },
+
+    
+    beforeDestroy: function(){
+        var me = this;
+        me.years = me.months = null;
+        Ext.destroyMembers(me, 'backRepeater', 'nextRepeater', 'okBtn', 'cancelBtn');
+        me.callParent();
+    },
+
+    
+    
+    finishRenderChildren: function () {
+        var me = this;
+
+        this.callParent(arguments);
+
+        if (this.showButtons) {
+            me.okBtn.finishRender();
+            me.cancelBtn.finishRender();
+        }
+    },
+
+    onDestroy: function() {
+        Ext.destroyMembers(this, 'okBtn', 'cancelBtn');
+        this.callParent();
+    }
+    
+});
+
+
+Ext.define('Ext.picker.Date', {
+    extend: 'Ext.Component',
+    requires: [
+        'Ext.XTemplate',
+        'Ext.button.Button',
+        'Ext.button.Split',
+        'Ext.util.ClickRepeater',
+        'Ext.util.KeyNav',
+        'Ext.EventObject',
+        'Ext.fx.Manager',
+        'Ext.picker.Month'
+    ],
+    alias: 'widget.datepicker',
+    alternateClassName: 'Ext.DatePicker',
+
+    childEls: [
+        'innerEl', 'eventEl', 'prevEl', 'nextEl', 'middleBtnEl', 'footerEl'
+    ],
+    
+    border: true,
+
+    renderTpl: [
+        '<div id="{id}-innerEl" role="grid">',
+            '<div role="presentation" class="{baseCls}-header">',
+                '<div class="{baseCls}-prev"><a id="{id}-prevEl" href="#" role="button" title="{prevText}"></a></div>',
+                '<div class="{baseCls}-month" id="{id}-middleBtnEl">{%this.renderMonthBtn(values, out)%}</div>',
+                '<div class="{baseCls}-next"><a id="{id}-nextEl" href="#" role="button" title="{nextText}"></a></div>',
+            '</div>',
+            '<table id="{id}-eventEl" class="{baseCls}-inner" cellspacing="0" role="presentation">',
+                '<thead role="presentation"><tr role="presentation">',
+                    '<tpl for="dayNames">',
+                        '<th role="columnheader" title="{.}"><span>{.:this.firstInitial}</span></th>',
+                    '</tpl>',
+                '</tr></thead>',
+                '<tbody role="presentation"><tr role="presentation">',
+                    '<tpl for="days">',
+                        '{#:this.isEndOfWeek}',
+                        '<td role="gridcell" id="{[Ext.id()]}">',
+                            '<a role="presentation" href="#" hidefocus="on" class="{parent.baseCls}-date" tabIndex="1">',
+                                '<em role="presentation"><span role="presentation"></span></em>',
+                            '</a>',
+                        '</td>',
+                    '</tpl>',
+                '</tr></tbody>',
+            '</table>',
+            '<tpl if="showToday">',
+                '<div id="{id}-footerEl" role="presentation" class="{baseCls}-footer">{%this.renderTodayBtn(values, out)%}</div>',
+            '</tpl>',
+        '</div>',
+        {
+            firstInitial: function(value) {
+                return Ext.picker.Date.prototype.getDayInitial(value);
+            },
+            isEndOfWeek: function(value) {
+                
+                
+                value--;
+                var end = value % 7 === 0 && value !== 0;
+                return end ? '</tr><tr role="row">' : '';
+            },
+            renderTodayBtn: function(values, out) {
+                Ext.DomHelper.generateMarkup(values.$comp.todayBtn.getRenderTree(), out);
+            },
+            renderMonthBtn: function(values, out) {
+                Ext.DomHelper.generateMarkup(values.$comp.monthBtn.getRenderTree(), out);
+            }
+        }
+    ],
+
+    
+    
+    todayText : 'Today',
+    
+    
+    
+    
+    ariaTitle: 'Date Picker: {0}',
+    
+    
+    
+    
+    ariaTitleDateFormat: 'F d, Y',
+    
+
+    
+
+    
+
+    
+    
+    todayTip : '{0} (Spacebar)',
+    
+
+    
+    
+    minText : 'This date is before the minimum date',
+    
+
+    
+    
+    maxText : 'This date is after the maximum date',
+    
+
+    
+
+    
+    
+    disabledDaysText : 'Disabled',
+    
+
+    
+    
+    disabledDatesText : 'Disabled',
+    
+
+    
+
+    
+
+    
+    
+    nextText : 'Next Month (Control+Right)',
+    
+
+    
+    
+    prevText : 'Previous Month (Control+Left)',
+    
+
+    
+    
+    monthYearText : 'Choose a month (Control+Up/Down to move years)',
+    
+    
+    
+    
+    monthYearFormat: 'F Y',
+    
+
+    
+    
+    startDay : 0,
+    
+
+    
+    
+    showToday : true,
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+    disableAnim: false,
+
+    
+    baseCls: Ext.baseCSSPrefix + 'datepicker',
+
+    
+
+    
+
+    
+    
+    longDayFormat: 'F d, Y',
+    
+
+    
+
+    
+    focusOnShow: false,
+
+    
+    
+    focusOnSelect: true,
+
+    width: 178,
+
+    
+    
+    initHour: 12, 
+
+    numDays: 42,
+
+    
+    initComponent : function() {
+        var me = this,
+            clearTime = Ext.Date.clearTime;
+
+        me.selectedCls = me.baseCls + '-selected';
+        me.disabledCellCls = me.baseCls + '-disabled';
+        me.prevCls = me.baseCls + '-prevday';
+        me.activeCls = me.baseCls + '-active';
+        me.nextCls = me.baseCls + '-prevday';
+        me.todayCls = me.baseCls + '-today';
+        me.dayNames = me.dayNames.slice(me.startDay).concat(me.dayNames.slice(0, me.startDay));
+
+        me.listeners = Ext.apply(me.listeners||{}, {
+            mousewheel: {
+                element: 'eventEl',
+                fn: me.handleMouseWheel,
+                scope: me
+            },
+            click: {
+                element: 'eventEl',
+                fn: me.handleDateClick, 
+                scope: me,
+                delegate: 'a.' + me.baseCls + '-date'
+            }
+        });
+        this.callParent();
+
+        me.value = me.value ?
+                 clearTime(me.value, true) : clearTime(new Date());
+
+        me.addEvents(
+            
+            'select'
+        );
+
+        me.initDisabledDays();
+    },
+
+    beforeRender: function () {
+        
+        var me = this,
+            days = new Array(me.numDays),
+            today = Ext.Date.format(new Date(), me.format);
+
+        
+        
+        if (me.up('menu')) {
+            me.addCls(Ext.baseCSSPrefix + 'menu');
+        }
+
+        me.monthBtn = new Ext.button.Split({
+            ownerCt: me,
+            ownerLayout: me.getComponentLayout(),
+            text: '',
+            tooltip: me.monthYearText,
+            listeners: {
+                click: me.showMonthPicker,
+                arrowclick: me.showMonthPicker,
+                scope: me
+            }
+        });
+
+        if (this.showToday) {
+            me.todayBtn = new Ext.button.Button({
+                ownerCt: me,
+                ownerLayout: me.getComponentLayout(),
+                text: Ext.String.format(me.todayText, today),
+                tooltip: Ext.String.format(me.todayTip, today),
+                tooltipType: 'title',
+                handler: me.selectToday,
+                scope: me
+            });
+        }
+
+        me.callParent();
+
+        Ext.applyIf(me, {
+            renderData: {}
+        });
+
+        Ext.apply(me.renderData, {
+            dayNames: me.dayNames,
+            showToday: me.showToday,
+            prevText: me.prevText,
+            nextText: me.nextText,
+            days: days
+        });
+    },
+
+    
+    
+    finishRenderChildren: function () {
+        var me = this;
+        
+        me.callParent();
+        me.monthBtn.finishRender();
+        if (me.showToday) {
+            me.todayBtn.finishRender();
+        }
+    },
+
+    
+    onRender : function(container, position){
+        var me = this;
+
+        me.callParent(arguments);
+        me.el.unselectable();
+        me.cells = me.eventEl.select('tbody td');
+        me.textNodes = me.eventEl.query('tbody td span');
+    },
+
+    
+    initEvents: function(){
+        var me = this,
+            eDate = Ext.Date,
+            day = eDate.DAY;
+
+        me.callParent();
+
+        me.prevRepeater = new Ext.util.ClickRepeater(me.prevEl, {
+            handler: me.showPrevMonth,
+            scope: me,
+            preventDefault: true,
+            stopDefault: true
+        });
+
+        me.nextRepeater = new Ext.util.ClickRepeater(me.nextEl, {
+            handler: me.showNextMonth,
+            scope: me,
+            preventDefault:true,
+            stopDefault:true
+        });
+
+        me.keyNav = new Ext.util.KeyNav(me.eventEl, Ext.apply({
+            scope: me,
+            left : function(e){
+                if(e.ctrlKey){
+                    me.showPrevMonth();
+                }else{
+                    me.update(eDate.add(me.activeDate, day, -1));
+                }
+            },
+
+            right : function(e){
+                if(e.ctrlKey){
+                    me.showNextMonth();
+                }else{
+                    me.update(eDate.add(me.activeDate, day, 1));
+                }
+            },
+
+            up : function(e){
+                if(e.ctrlKey){
+                    me.showNextYear();
+                }else{
+                    me.update(eDate.add(me.activeDate, day, -7));
+                }
+            },
+
+            down : function(e){
+                if(e.ctrlKey){
+                    me.showPrevYear();
+                }else{
+                    me.update(eDate.add(me.activeDate, day, 7));
+                }
+            },
+            pageUp : me.showNextMonth,
+            pageDown : me.showPrevMonth,
+            enter : function(e){
+                e.stopPropagation();
+                return true;
+            }
+        }, me.keyNavConfig));
+
+        if (me.showToday) {
+            me.todayKeyListener = me.eventEl.addKeyListener(Ext.EventObject.SPACE, me.selectToday,  me);
+        }
+        me.update(me.value);
+    },
+
+    
+    initDisabledDays : function(){
+        var me = this,
+            dd = me.disabledDates,
+            re = '(?:',
+            len,
+            d, dLen, dI;
+
+        if(!me.disabledDatesRE && dd){
+                len = dd.length - 1;
+
+            dLen = dd.length;
+
+            for (d = 0; d < dLen; d++) {
+                dI = dd[d];
+
+                re += Ext.isDate(dI) ? '^' + Ext.String.escapeRegex(Ext.Date.dateFormat(dI, me.format)) + '$' : dI;
+                if (d != len) {
+                    re += '|';
+                }
+            }
+
+            me.disabledDatesRE = new RegExp(re + ')');
+        }
+    },
+
+    
+    setDisabledDates : function(dd){
+        var me = this;
+
+        if(Ext.isArray(dd)){
+            me.disabledDates = dd;
+            me.disabledDatesRE = null;
+        }else{
+            me.disabledDatesRE = dd;
+        }
+        me.initDisabledDays();
+        me.update(me.value, true);
+        return me;
+    },
+
+    
+    setDisabledDays : function(dd){
+        this.disabledDays = dd;
+        return this.update(this.value, true);
+    },
+
+    
+    setMinDate : function(dt){
+        this.minDate = dt;
+        return this.update(this.value, true);
+    },
+
+    
+    setMaxDate : function(dt){
+        this.maxDate = dt;
+        return this.update(this.value, true);
+    },
+
+    
+    setValue : function(value){
+        this.value = Ext.Date.clearTime(value, true);
+        return this.update(this.value);
+    },
+
+    
+    getValue : function(){
+        return this.value;
+    },
+
+    
+    
+    getDayInitial: function(value){
+        return value.substr(0,1);
+    },
+    
+
+    
+    focus : function(){
+        this.update(this.activeDate);
+    },
+
+    
+    onEnable: function(){
+        this.callParent();
+        this.setDisabledStatus(false);
+        this.update(this.activeDate);
+
+    },
+
+    
+    onDisable : function(){
+        this.callParent();
+        this.setDisabledStatus(true);
+    },
+
+    
+    setDisabledStatus : function(disabled){
+        var me = this;
+
+        me.keyNav.setDisabled(disabled);
+        me.prevRepeater.setDisabled(disabled);
+        me.nextRepeater.setDisabled(disabled);
+        if (me.showToday) {
+            me.todayKeyListener.setDisabled(disabled);
+            me.todayBtn.setDisabled(disabled);
+        }
+    },
+
+    
+    getActive: function(){
+        return this.activeDate || this.value;
+    },
+
+    
+    runAnimation: function(isHide){
+        var picker = this.monthPicker,
+            options = {
+                duration: 200,
+                callback: function(){
+                    if (isHide) {
+                        picker.hide();
+                    } else {
+                        picker.show();
+                    }
+                }
+            };
+
+        if (isHide) {
+            picker.el.slideOut('t', options);
+        } else {
+            picker.el.slideIn('t', options);
+        }
+    },
+
+    
+    hideMonthPicker : function(animate){
+        var me = this,
+            picker = me.monthPicker;
+
+        if (picker) {
+            if (me.shouldAnimate(animate)) {
+                me.runAnimation(true);
+            } else {
+                picker.hide();
+            }
+        }
+        return me;
+    },
+
+    
+    showMonthPicker : function(animate){
+        var me = this,
+            picker;
+        
+        if (me.rendered && !me.disabled) {
+            picker = me.createMonthPicker();
+            picker.setValue(me.getActive());
+            picker.setSize(me.getSize());
+            picker.setPosition(-1, -1);
+            if (me.shouldAnimate(animate)) {
+                me.runAnimation(false);
+            } else {
+                picker.show();
+            }
+        }
+        return me;
+    },
+    
+    
+    shouldAnimate: function(animate){
+        return Ext.isDefined(animate) ? animate : !this.disableAnim;
+    },
+
+    
+    createMonthPicker: function(){
+        var me = this,
+            picker = me.monthPicker;
+
+        if (!picker) {
+            me.monthPicker = picker = new Ext.picker.Month({
+                renderTo: me.el,
+                floating: true,
+                shadow: false,
+                small: me.showToday === false,
+                listeners: {
+                    scope: me,
+                    cancelclick: me.onCancelClick,
+                    okclick: me.onOkClick,
+                    yeardblclick: me.onOkClick,
+                    monthdblclick: me.onOkClick
+                }
+            });
+            if (!me.disableAnim) {
+                
+                picker.el.setStyle('display', 'none');
+            }
+            me.on('beforehide', Ext.Function.bind(me.hideMonthPicker, me, [false]));
+        }
+        return picker;
+    },
+
+    
+    onOkClick: function(picker, value){
+        var me = this,
+            month = value[0],
+            year = value[1],
+            date = new Date(year, month, me.getActive().getDate());
+
+        if (date.getMonth() !== month) {
+            
+            date = Ext.Date.getLastDateOfMonth(new Date(year, month, 1));
+        }
+        me.update(date);
+        me.hideMonthPicker();
+    },
+
+    
+    onCancelClick: function(){
+        
+        this.selectedUpdate(this.activeDate);
+        this.hideMonthPicker();
+    },
+
+    
+    showPrevMonth : function(e){
+        return this.update(Ext.Date.add(this.activeDate, Ext.Date.MONTH, -1));
+    },
+
+    
+    showNextMonth : function(e){
+        return this.update(Ext.Date.add(this.activeDate, Ext.Date.MONTH, 1));
+    },
+
+    
+    showPrevYear : function(){
+        this.update(Ext.Date.add(this.activeDate, Ext.Date.YEAR, -1));
+    },
+
+    
+    showNextYear : function(){
+        this.update(Ext.Date.add(this.activeDate, Ext.Date.YEAR, 1));
+    },
+
+    
+    handleMouseWheel : function(e){
+        e.stopEvent();
+        if(!this.disabled){
+            var delta = e.getWheelDelta();
+            if(delta > 0){
+                this.showPrevMonth();
+            } else if(delta < 0){
+                this.showNextMonth();
+            }
+        }
+    },
+
+    
+    handleDateClick : function(e, t){
+        var me = this,
+            handler = me.handler;
+
+        e.stopEvent();
+        if(!me.disabled && t.dateValue && !Ext.fly(t.parentNode).hasCls(me.disabledCellCls)){
+            me.doCancelFocus = me.focusOnSelect === false;
+            me.setValue(new Date(t.dateValue));
+            delete me.doCancelFocus;
+            me.fireEvent('select', me, me.value);
+            if (handler) {
+                handler.call(me.scope || me, me, me.value);
+            }
+            
+            
+            
+            
+            me.onSelect();
+        }
+    },
+
+    
+    onSelect: function() {
+        if (this.hideOnSelect) {
+             this.hide();
+         }
+    },
+
+    
+    selectToday : function(){
+        var me = this,
+            btn = me.todayBtn,
+            handler = me.handler;
+
+        if(btn && !btn.disabled){
+            me.setValue(Ext.Date.clearTime(new Date()));
+            me.fireEvent('select', me, me.value);
+            if (handler) {
+                handler.call(me.scope || me, me, me.value);
+            }
+            me.onSelect();
+        }
+        return me;
+    },
+
+    
+    selectedUpdate: function(date){
+        var me        = this,
+            t         = date.getTime(),
+            cells     = me.cells,
+            cls       = me.selectedCls,
+            cellItems = cells.elements,
+            c,
+            cLen      = cellItems.length,
+            cell;
+
+        cells.removeCls(cls);
+
+        for (c = 0; c < cLen; c++) {
+            cell = Ext.fly(cellItems[c]);
+
+            if (cell.dom.firstChild.dateValue == t) {
+                me.fireEvent('highlightitem', me, cell);
+                cell.addCls(cls);
+
+                if(me.isVisible() && !me.doCancelFocus){
+                    Ext.fly(cell.dom.firstChild).focus(50);
+                }
+
+                break;
+            }
+        }
+    },
+
+    
+    fullUpdate: function(date){
+        var me = this,
+            cells = me.cells.elements,
+            textNodes = me.textNodes,
+            disabledCls = me.disabledCellCls,
+            eDate = Ext.Date,
+            i = 0,
+            extraDays = 0,
+            visible = me.isVisible(),
+            sel = +eDate.clearTime(date, true),
+            today = +eDate.clearTime(new Date()),
+            min = me.minDate ? eDate.clearTime(me.minDate, true) : Number.NEGATIVE_INFINITY,
+            max = me.maxDate ? eDate.clearTime(me.maxDate, true) : Number.POSITIVE_INFINITY,
+            ddMatch = me.disabledDatesRE,
+            ddText = me.disabledDatesText,
+            ddays = me.disabledDays ? me.disabledDays.join('') : false,
+            ddaysText = me.disabledDaysText,
+            format = me.format,
+            days = eDate.getDaysInMonth(date),
+            firstOfMonth = eDate.getFirstDateOfMonth(date),
+            startingPos = firstOfMonth.getDay() - me.startDay,
+            previousMonth = eDate.add(date, eDate.MONTH, -1),
+            longDayFormat = me.longDayFormat,
+            prevStart,
+            current,
+            disableToday,
+            tempDate,
+            setCellClass,
+            html,
+            cls,
+            formatValue,
+            value;
+
+        if (startingPos < 0) {
+            startingPos += 7;
+        }
+
+        days += startingPos;
+        prevStart = eDate.getDaysInMonth(previousMonth) - startingPos;
+        current = new Date(previousMonth.getFullYear(), previousMonth.getMonth(), prevStart, me.initHour);
+
+        if (me.showToday) {
+            tempDate = eDate.clearTime(new Date());
+            disableToday = (tempDate < min || tempDate > max ||
+                (ddMatch && format && ddMatch.test(eDate.dateFormat(tempDate, format))) ||
+                (ddays && ddays.indexOf(tempDate.getDay()) != -1));
+
+            if (!me.disabled) {
+                me.todayBtn.setDisabled(disableToday);
+                me.todayKeyListener.setDisabled(disableToday);
+            }
+        }
+
+        setCellClass = function(cell){
+            value = +eDate.clearTime(current, true);
+            cell.title = eDate.format(current, longDayFormat);
+            
+            cell.firstChild.dateValue = value;
+            if(value == today){
+                cell.className += ' ' + me.todayCls;
+                cell.title = me.todayText;
+            }
+            if(value == sel){
+                cell.className += ' ' + me.selectedCls;
+                me.fireEvent('highlightitem', me, cell);
+                if (visible && me.floating) {
+                    Ext.fly(cell.firstChild).focus(50);
+                }
+            }
+            
+            if(value < min) {
+                cell.className = disabledCls;
+                cell.title = me.minText;
+                return;
+            }
+            if(value > max) {
+                cell.className = disabledCls;
+                cell.title = me.maxText;
+                return;
+            }
+            if(ddays){
+                if(ddays.indexOf(current.getDay()) != -1){
+                    cell.title = ddaysText;
+                    cell.className = disabledCls;
+                }
+            }
+            if(ddMatch && format){
+                formatValue = eDate.dateFormat(current, format);
+                if(ddMatch.test(formatValue)){
+                    cell.title = ddText.replace('%0', formatValue);
+                    cell.className = disabledCls;
+                }
+            }
+        };
+
+        for(; i < me.numDays; ++i) {
+            if (i < startingPos) {
+                html = (++prevStart);
+                cls = me.prevCls;
+            } else if (i >= days) {
+                html = (++extraDays);
+                cls = me.nextCls;
+            } else {
+                html = i - startingPos + 1;
+                cls = me.activeCls;
+            }
+            textNodes[i].innerHTML = html;
+            cells[i].className = cls;
+            current.setDate(current.getDate() + 1);
+            setCellClass(cells[i]);
+        }
+
+        me.monthBtn.setText(Ext.Date.format(date, me.monthYearFormat));
+    },
+
+    
+    update : function(date, forceRefresh){
+        var me = this,
+            active = me.activeDate;
+
+        if (me.rendered) {
+            me.activeDate = date;
+            if(!forceRefresh && active && me.el && active.getMonth() == date.getMonth() && active.getFullYear() == date.getFullYear()){
+                me.selectedUpdate(date, active);
+            } else {
+                me.fullUpdate(date, active);
+            }
+            me.innerEl.dom.title = Ext.String.format(me.ariaTitle, Ext.Date.format(me.activeDate, me.ariaTitleDateFormat));
+        }
+        return me;
+    },
+
+    
+    beforeDestroy : function() {
+        var me = this;
+
+        if (me.rendered) {
+            Ext.destroy(
+                me.todayKeyListener,
+                me.keyNav,
+                me.monthPicker,
+                me.monthBtn,
+                me.nextRepeater,
+                me.prevRepeater,
+                me.todayBtn
+            );
+            delete me.textNodes;
+            delete me.cells.elements;
+        }
+        me.callParent();
+    },
+
+    
+    onShow: function() {
+        this.callParent(arguments);
+        if (this.focusOnShow) {
+            this.focus();
+        }
+    }
+},
+
+
+function() {
+    var proto = this.prototype,
+        date = Ext.Date;
+
+    proto.monthNames = date.monthNames;
+    proto.dayNames   = date.dayNames;
+    proto.format     = date.defaultFormat;
+});
+
+
+Ext.define('Ext.form.field.Date', {
+    extend:'Ext.form.field.Picker',
+    alias: 'widget.datefield',
+    requires: ['Ext.picker.Date'],
+    alternateClassName: ['Ext.form.DateField', 'Ext.form.Date'],
+
+    
+    
+    format : "m/d/Y",
+    
+    
+    
+    altFormats : "m/d/Y|n/j/Y|n/j/y|m/j/y|n/d/y|m/j/Y|n/d/Y|m-d-y|m-d-Y|m/d|m-d|md|mdy|mdY|d|Y-m-d|n-j|n/j",
+    
+    
+    
+    disabledDaysText : "Disabled",
+    
+    
+    
+    disabledDatesText : "Disabled",
+    
+    
+    
+    minText : "The date in this field must be equal to or after {0}",
+    
+    
+    
+    maxText : "The date in this field must be equal to or before {0}",
+    
+    
+    
+    invalidText : "{0} is not a valid date - it must be in the format {1}",
+    
+    
+    triggerCls : Ext.baseCSSPrefix + 'form-date-trigger',
+    
+    showToday : true,
+    
+    
+    
+    
+
+    
+    
+    
+    useStrict: undefined,
+
+    
+    
+    initTime: '12', 
+
+    initTimeFormat: 'H',
+
+    matchFieldWidth: false,
+    
+    
+    startDay: 0,
+    
+
+    initComponent : function(){
+        var me = this,
+            isString = Ext.isString,
+            min, max;
+
+        min = me.minValue;
+        max = me.maxValue;
+        if(isString(min)){
+            me.minValue = me.parseDate(min);
+        }
+        if(isString(max)){
+            me.maxValue = me.parseDate(max);
+        }
+        me.disabledDatesRE = null;
+        me.initDisabledDays();
+
+        me.callParent();
+    },
+
+    initValue: function() {
+        var me = this,
+            value = me.value;
+
+        
+        if (Ext.isString(value)) {
+            me.value = me.rawToValue(value);
+        }
+
+        me.callParent();
+    },
+
+    
+    initDisabledDays : function(){
+        if(this.disabledDates){
+            var dd   = this.disabledDates,
+                len  = dd.length - 1,
+                re   = "(?:",
+                d,
+                dLen = dd.length,
+                date;
+
+            for (d = 0; d < dLen; d++) {
+                date = dd[d];
+
+                re += Ext.isDate(date) ? '^' + Ext.String.escapeRegex(date.dateFormat(this.format)) + '$' : date;
+                if (d !== len) {
+                    re += '|';
+                }
+            }
+
+            this.disabledDatesRE = new RegExp(re + ')');
+        }
+    },
+
+    
+    setDisabledDates : function(dd){
+        var me = this,
+            picker = me.picker;
+
+        me.disabledDates = dd;
+        me.initDisabledDays();
+        if (picker) {
+            picker.setDisabledDates(me.disabledDatesRE);
+        }
+    },
+
+    
+    setDisabledDays : function(dd){
+        var picker = this.picker;
+
+        this.disabledDays = dd;
+        if (picker) {
+            picker.setDisabledDays(dd);
+        }
+    },
+
+    
+    setMinValue : function(dt){
+        var me = this,
+            picker = me.picker,
+            minValue = (Ext.isString(dt) ? me.parseDate(dt) : dt);
+
+        me.minValue = minValue;
+        if (picker) {
+            picker.minText = Ext.String.format(me.minText, me.formatDate(me.minValue));
+            picker.setMinDate(minValue);
+        }
+    },
+
+    
+    setMaxValue : function(dt){
+        var me = this,
+            picker = me.picker,
+            maxValue = (Ext.isString(dt) ? me.parseDate(dt) : dt);
+
+        me.maxValue = maxValue;
+        if (picker) {
+            picker.maxText = Ext.String.format(me.maxText, me.formatDate(me.maxValue));
+            picker.setMaxDate(maxValue);
+        }
+    },
+
+    
+    getErrors: function(value) {
+        var me = this,
+            format = Ext.String.format,
+            clearTime = Ext.Date.clearTime,
+            errors = me.callParent(arguments),
+            disabledDays = me.disabledDays,
+            disabledDatesRE = me.disabledDatesRE,
+            minValue = me.minValue,
+            maxValue = me.maxValue,
+            len = disabledDays ? disabledDays.length : 0,
+            i = 0,
+            svalue,
+            fvalue,
+            day,
+            time;
+
+        value = me.formatDate(value || me.processRawValue(me.getRawValue()));
+
+        if (value === null || value.length < 1) { 
+             return errors;
+        }
+
+        svalue = value;
+        value = me.parseDate(value);
+        if (!value) {
+            errors.push(format(me.invalidText, svalue, Ext.Date.unescapeFormat(me.format)));
+            return errors;
+        }
+
+        time = value.getTime();
+        if (minValue && time < clearTime(minValue).getTime()) {
+            errors.push(format(me.minText, me.formatDate(minValue)));
+        }
+
+        if (maxValue && time > clearTime(maxValue).getTime()) {
+            errors.push(format(me.maxText, me.formatDate(maxValue)));
+        }
+
+        if (disabledDays) {
+            day = value.getDay();
+
+            for(; i < len; i++) {
+                if (day === disabledDays[i]) {
+                    errors.push(me.disabledDaysText);
+                    break;
+                }
+            }
+        }
+
+        fvalue = me.formatDate(value);
+        if (disabledDatesRE && disabledDatesRE.test(fvalue)) {
+            errors.push(format(me.disabledDatesText, fvalue));
+        }
+
+        return errors;
+    },
+
+    rawToValue: function(rawValue) {
+        return this.parseDate(rawValue) || rawValue || null;
+    },
+
+    valueToRaw: function(value) {
+        return this.formatDate(this.parseDate(value));
+    },
+
+    
+
+    
+    safeParse : function(value, format) {
+        var me = this,
+            utilDate = Ext.Date,
+            result = null,
+            strict = me.useStrict,
+            parsedDate;
+
+        if (utilDate.formatContainsHourInfo(format)) {
+            
+            result = utilDate.parse(value, format, strict);
+        } else {
+            
+            parsedDate = utilDate.parse(value + ' ' + me.initTime, format + ' ' + me.initTimeFormat, strict);
+            if (parsedDate) {
+                result = utilDate.clearTime(parsedDate);
+            }
+        }
+        return result;
+    },
+
+    
+    getSubmitValue: function() {
+        var format = this.submitFormat || this.format,
+            value = this.getValue();
+
+        return value ? Ext.Date.format(value, format) : '';
+    },
+
+    
+    parseDate : function(value) {
+        if(!value || Ext.isDate(value)){
+            return value;
+        }
+
+        var me = this,
+            val = me.safeParse(value, me.format),
+            altFormats = me.altFormats,
+            altFormatsArray = me.altFormatsArray,
+            i = 0,
+            len;
+
+        if (!val && altFormats) {
+            altFormatsArray = altFormatsArray || altFormats.split('|');
+            len = altFormatsArray.length;
+            for (; i < len && !val; ++i) {
+                val = me.safeParse(value, altFormatsArray[i]);
+            }
+        }
+        return val;
+    },
+
+    
+    formatDate : function(date){
+        return Ext.isDate(date) ? Ext.Date.dateFormat(date, this.format) : date;
+    },
+
+    createPicker: function() {
+        var me = this,
+            format = Ext.String.format;
+
+        return new Ext.picker.Date({
+            pickerField: me,
+            ownerCt: me.ownerCt,
+            renderTo: document.body,
+            floating: true,
+            hidden: true,
+            focusOnShow: true,
+            minDate: me.minValue,
+            maxDate: me.maxValue,
+            disabledDatesRE: me.disabledDatesRE,
+            disabledDatesText: me.disabledDatesText,
+            disabledDays: me.disabledDays,
+            disabledDaysText: me.disabledDaysText,
+            format: me.format,
+            showToday: me.showToday,
+            startDay: me.startDay,
+            minText: format(me.minText, me.formatDate(me.minValue)),
+            maxText: format(me.maxText, me.formatDate(me.maxValue)),
+            listeners: {
+                scope: me,
+                select: me.onSelect
+            },
+            keyNavConfig: {
+                esc: function() {
+                    me.collapse();
+                }
+            }
+        });
+    },
+
+    onSelect: function(m, d) {
+        var me = this;
+
+        me.setValue(d);
+        me.fireEvent('select', me, d);
+        me.collapse();
+    },
+
+    
+    onExpand: function() {
+        var value = this.getValue();
+        this.picker.setValue(Ext.isDate(value) ? value : new Date());
+    },
+
+    
+    onCollapse: function() {
+        this.focus(false, 60);
+    },
+
+    
+    beforeBlur : function(){
+        var me = this,
+            v = me.parseDate(me.getRawValue()),
+            focusTask = me.focusTask;
+
+        if (focusTask) {
+            focusTask.cancel();
+        }
+
+        if (v) {
+            me.setValue(v);
+        }
+    }
+
+    
+    
+    
+    
+});
+
+
+Ext.define("Ext.form.field.File", {
+    extend: 'Ext.form.field.Trigger',
+    alias: ['widget.filefield', 'widget.fileuploadfield'],
+    alternateClassName: ['Ext.form.FileUploadField', 'Ext.ux.form.FileUploadField', 'Ext.form.File'],
+    uses: ['Ext.button.Button', 'Ext.layout.component.field.Field'],
+
+    
+    
+    buttonText: 'Browse...',
+    
+
+    
+    buttonOnly: false,
+
+    
+    buttonMargin: 3,
+
+    
+
+    
+
+    
+
+    
+
+    
+    fieldBodyCls: Ext.baseCSSPrefix + 'form-file-wrap',
+
+    
+    readOnly: true,
+
+    
+    triggerNoEditCls: '',
+
+    
+    componentLayout: 'triggerfield',
+
+    
+    childEls: ['fileInputEl', 'buttonEl', 'buttonEl-btnEl', 'browseButtonWrap'],
+
+    
+    onRender: function() {
+        var me = this,
+            inputEl;
+
+        me.callParent(arguments);
+
+        inputEl = me.inputEl;
+        inputEl.dom.name = ''; 
+
+        me.fileInputEl.dom.name = me.getName();
+        me.fileInputEl.on({
+            scope: me,
+            change: me.onFileChange
+        });
+
+        if (me.buttonOnly) {
+            me.inputCell.setDisplayed(false);
+        }
+
+        
+        me.browseButtonWrap.dom.style.width = (me.browseButtonWrap.dom.lastChild.offsetWidth + me.buttonEl.getMargin('lr')) + 'px';
+        if (Ext.isIE) {
+            me.buttonEl.repaint();
+        }
+    },
+
+    
+    getTriggerMarkup: function() {
+        var me = this,
+            result,
+            btn = Ext.widget('button', Ext.apply({
+                id: me.id + '-buttonEl',
+                ui: me.ui,
+                disabled: me.disabled,
+                text: me.buttonText,
+                cls: Ext.baseCSSPrefix + 'form-file-btn',
+                preventDefault: false,
+                style: me.buttonOnly ? '' : 'margin-left:' + me.buttonMargin + 'px'
+            }, me.buttonConfig)),
+            btnCfg = btn.getRenderTree(),
+            inputElCfg = {
+                id: me.id + '-fileInputEl',
+                cls: Ext.baseCSSPrefix + 'form-file-input',
+                tag: 'input',
+                type: 'file',
+                size: 1
+            };
+        if (me.disabled) {
+            inputElCfg.disabled = true;
+        }
+        btnCfg.cn = inputElCfg;
+        result = '<td id="' + me.id + '-browseButtonWrap">' + Ext.DomHelper.markup(btnCfg) + '</td>';
+        btn.destroy();
+        return result;
+    },
+
+    
+    createFileInput : function() {
+        var me = this;
+        me.fileInputEl = me.buttonEl.createChild({
+            name: me.getName(),
+            id: me.id + '-fileInputEl',
+            cls: Ext.baseCSSPrefix + 'form-file-input',
+            tag: 'input',
+            type: 'file',
+            size: 1
+        });
+        me.fileInputEl.on({
+            scope: me,
+            change: me.onFileChange
+        });
+    },
+
+    
+    onFileChange: function() {
+        this.lastValue = null; 
+        Ext.form.field.File.superclass.setValue.call(this, this.fileInputEl.dom.value);
+    },
+
+    
+    setValue: Ext.emptyFn,
+
+    reset : function(){
+        var me = this;
+        if (me.rendered) {
+            me.fileInputEl.remove();
+            me.createFileInput();
+            me.inputEl.dom.value = '';
+        }
+        me.callParent();
+    },
+
+    onDisable: function(){
+        this.callParent();
+        this.disableItems();
+    },
+    
+    disableItems: function(){
+        var file = this.fileInputEl;
+        if (file) {
+            file.dom.disabled = true;
+        }
+        this['buttonEl-btnEl'].dom.disabled = true;
+    },
+
+    onEnable: function(){
+        var me = this;
+        me.callParent();
+        me.fileInputEl.dom.disabled = false;
+        this['buttonEl-btnEl'].dom.disabled = false;
+    },
+
+    isFileUpload: function() {
+        return true;
+    },
+
+    extractFileInput: function() {
+        var fileInput = this.fileInputEl.dom;
+        this.reset();
+        return fileInput;
+    },
+
+    onDestroy: function(){
+        Ext.destroyMembers(this, 'fileInputEl', 'buttonEl');
+        this.callParent();
+    }
+});
+
+
+Ext.define('Ext.form.field.Hidden', {
+    extend:'Ext.form.field.Base',
+    alias: ['widget.hiddenfield', 'widget.hidden'],
+    alternateClassName: 'Ext.form.Hidden',
+
+    
+    inputType : 'hidden',
+    hideLabel: true,
+    
+    initComponent: function(){
+        this.formItemCls += '-hidden';
+        this.callParent();    
+    },
+    
+    
+    isEqual: function(value1, value2) {
+        return this.isEqualAsString(value1, value2);
+    },
+
+    
+    initEvents: Ext.emptyFn,
+    setSize : Ext.emptyFn,
+    setWidth : Ext.emptyFn,
+    setHeight : Ext.emptyFn,
+    setPosition : Ext.emptyFn,
+    setPagePosition : Ext.emptyFn,
+    markInvalid : Ext.emptyFn,
+    clearInvalid : Ext.emptyFn
+});
+
+
+Ext.define('Ext.layout.component.field.HtmlEditor', {
+    extend: 'Ext.layout.component.field.Field',
+    alias: ['layout.htmleditor'],
+
+    type: 'htmleditor',
+
+    
+    toolbarSizePolicy: {
+        setsWidth: 0,
+        setsHeight: 0
+    },
+
+    beginLayout: function(ownerContext) {
+        this.callParent(arguments);
+
+        ownerContext.textAreaContext = ownerContext.getEl('textareaEl');
+        ownerContext.iframeContext   = ownerContext.getEl('iframeEl');
+        ownerContext.toolbarContext  = ownerContext.context.getCmp(this.owner.getToolbar());
+    },
+    
+    
+    renderItems: Ext.emptyFn,
+
+    getItemSizePolicy: function (item) {
+        
+        return this.toolbarSizePolicy;
+    },
+
+    getLayoutItems: function () {
+        var toolbar = this.owner.getToolbar();
+        
+        return toolbar ? [toolbar] : [];
+    },
+
+    getRenderTarget: function() {
+        return this.owner.bodyEl;
+    },
+
+    publishInnerHeight: function (ownerContext, height) {
+        var me = this,
+            innerHeight = height - me.measureLabelErrorHeight(ownerContext) -
+                          ownerContext.toolbarContext.getProp('height') -
+                          ownerContext.bodyCellContext.getPaddingInfo().height;
+
+        
+        if (Ext.isNumber(innerHeight)) {
+            ownerContext.textAreaContext.setHeight(innerHeight);
+            ownerContext.iframeContext.setHeight(innerHeight);
+        } else {
+            me.done = false;
+        }
+    }
+});
+
+
+Ext.define('Ext.picker.Color', {
+    extend: 'Ext.Component',
+    requires: 'Ext.XTemplate',
+    alias: 'widget.colorpicker',
+    alternateClassName: 'Ext.ColorPalette',
+
+    
+    componentCls : Ext.baseCSSPrefix + 'color-picker',
+
+    
+    selectedCls: Ext.baseCSSPrefix + 'color-picker-selected',
+
+    
+    value : null,
+
+    
+    clickEvent :'click',
+
+    
+    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'
+    ],
+
+    
+
+    
+
+    colorRe: /(?:^|\s)color-(.{6})(?:\s|$)/,
+    
+    renderTpl: [
+        '<tpl for="colors">',
+            '<a href="#" class="color-{.}" hidefocus="on">',
+                '<em><span style="background:#{.}" unselectable="on">&#160;</span></em>',
+            '</a>',
+        '</tpl>'
+    ],
+
+    
+    initComponent : function(){
+        var me = this;
+
+        me.callParent(arguments);
+        me.addEvents(
+            
+            'select'
+        );
+
+        if (me.handler) {
+            me.on('select', me.handler, me.scope, true);
+        }
+    },
+
+
+    
+    initRenderData : function(){
+        var me = this;
+        return Ext.apply(me.callParent(), {
+            itemCls: me.itemCls,
+            colors: me.colors
+        });
+    },
+
+    onRender : function(){
+        var me = this,
+            clickEvent = me.clickEvent;
+
+        me.callParent(arguments);
+
+        me.mon(me.el, clickEvent, me.handleClick, me, {delegate: 'a'});
+        
+        if(clickEvent != 'click'){
+            me.mon(me.el, 'click', Ext.emptyFn, me, {delegate: 'a', stopEvent: true});
+        }
+    },
+
+    
+    afterRender : function(){
+        var me = this,
+            value;
+
+        me.callParent(arguments);
+        if (me.value) {
+            value = me.value;
+            me.value = null;
+            me.select(value, true);
+        }
+    },
+
+    
+    handleClick : function(event, target){
+        var me = this,
+            color;
+
+        event.stopEvent();
+        if (!me.disabled) {
+            color = target.className.match(me.colorRe)[1];
+            me.select(color.toUpperCase());
+        }
+    },
+
+    
+    select : function(color, suppressEvent){
+
+        var me = this,
+            selectedCls = me.selectedCls,
+            value = me.value,
+            el;
+
+        color = color.replace('#', '');
+        if (!me.rendered) {
+            me.value = color;
+            return;
+        }
+
+
+        if (color != value || me.allowReselect) {
+            el = me.el;
+
+            if (me.value) {
+                el.down('a.color-' + value).removeCls(selectedCls);
+            }
+            el.down('a.color-' + color).addCls(selectedCls);
+            me.value = color;
+            if (suppressEvent !== true) {
+                me.fireEvent('select', me, color);
+            }
+        }
+    },
+
+    
+    getValue: function(){
+        return this.value || null;
+    }
+});
+
+
+Ext.define('Ext.form.field.HtmlEditor', {
+    extend:'Ext.Component',
+    mixins: {
+        labelable: 'Ext.form.Labelable',
+        field: 'Ext.form.field.Field'
+    },
+    alias: 'widget.htmleditor',
+    alternateClassName: 'Ext.form.HtmlEditor',
+    requires: [
+        'Ext.tip.QuickTipManager',
+        'Ext.picker.Color',
+        'Ext.toolbar.Item',
+        'Ext.toolbar.Toolbar',
+        'Ext.util.Format',
+        'Ext.layout.component.field.HtmlEditor'
+    ],
+
+    childEls: [
+        'iframeEl', 'textareaEl'
+    ],
+
+    fieldSubTpl: [
+        '{beforeTextAreaTpl}',
+        '<textarea id="{cmpId}-textareaEl" name="{name}" tabIndex="-1" {inputAttrTpl}',
+                 ' class="{textareaCls}" style="{size}" autocomplete="off">',
+            '{[Ext.util.Format.htmlEncode(values.value)]}',
+        '</textarea>',
+        '{afterTextAreaTpl}',
+        '{beforeIFrameTpl}',
+        '<iframe id="{cmpId}-iframeEl" name="{iframeName}" frameBorder="0" {iframeAttrTpl}',
+               ' style="overflow:auto;{size}" src="{iframeSrc}"></iframe>',
+        '{afterIFrameTpl}',
+        {
+            disableFormats: true
+        }
+    ],
+
+    subTplInsertions: [
+        
+        'beforeTextAreaTpl',
+
+        
+        'afterTextAreaTpl',
+
+        
+        'beforeIFrameTpl',
+
+        
+        'afterIFrameTpl',
+
+        
+        'iframeAttrTpl',
+
+        
+        'inputAttrTpl'
+    ],
+
+    
+    enableFormat : true,
+    
+    enableFontSize : true,
+    
+    enableColors : true,
+    
+    enableAlignments : true,
+    
+    enableLists : true,
+    
+    enableSourceEdit : true,
+    
+    enableLinks : true,
+    
+    enableFont : true,
+    
+    
+    createLinkText : 'Please enter the URL for the link:',
+    
+    
+    defaultLinkValue : 'http:/'+'/',
+    
+    fontFamilies : [
+        'Arial',
+        'Courier New',
+        'Tahoma',
+        'Times New Roman',
+        'Verdana'
+    ],
+    defaultFont: 'tahoma',
+    
+    defaultValue: (Ext.isOpera || Ext.isIE6) ? '&#160;' : '&#8203;',
+
+    editorWrapCls: Ext.baseCSSPrefix + 'html-editor-wrap',
+
+    componentLayout: 'htmleditor',
+
+    
+    initialized : false,
+    activated : false,
+    sourceEditMode : false,
+    iframePad:3,
+    hideMode:'offsets',
+
+    afterBodyEl: '</div>',
+
+    maskOnDisable: true,
+
+    
+    initComponent : function(){
+        var me = this;
+
+        me.addEvents(
+            
+            'initialize',
+            
+            'activate',
+             
+            'beforesync',
+             
+            'beforepush',
+             
+            'sync',
+             
+            'push',
+             
+            'editmodechange'
+        );
+
+        me.callParent(arguments);
+        me.createToolbar(me);
+
+        
+        me.initLabelable();
+        me.initField();
+    },
+
+    
+    getRefItems: function() {
+        return [ this.toolbar ];
+    },
+
+    
+    createToolbar : function(editor){
+        var me = this,
+            items = [], i,
+            tipsEnabled = Ext.tip.QuickTipManager && Ext.tip.QuickTipManager.isEnabled(),
+            baseCSSPrefix = Ext.baseCSSPrefix,
+            fontSelectItem, toolbar, undef;
+
+        function btn(id, toggle, handler){
+            return {
+                itemId : id,
+                cls : baseCSSPrefix + 'btn-icon',
+                iconCls: baseCSSPrefix + 'edit-'+id,
+                enableToggle:toggle !== false,
+                scope: editor,
+                handler:handler||editor.relayBtnCmd,
+                clickEvent: 'mousedown',
+                tooltip: tipsEnabled ? editor.buttonTips[id] || undef : undef,
+                overflowText: editor.buttonTips[id].title || undef,
+                tabIndex: -1
+            };
+        }
+
+
+        if (me.enableFont && !Ext.isSafari2) {
+            fontSelectItem = Ext.widget('component', {
+                renderTpl: [
+                    '<select id="{id}-selectEl" class="{cls}">',
+                        '<tpl for="fonts">',
+                            '<option value="{[values.toLowerCase()]}" style="font-family:{.}"<tpl if="values.toLowerCase()==parent.defaultFont"> selected</tpl>>{.}</option>',
+                        '</tpl>',
+                    '</select>'
+                ],
+                renderData: {
+                    cls: baseCSSPrefix + 'font-select',
+                    fonts: me.fontFamilies,
+                    defaultFont: me.defaultFont
+                },
+                childEls: ['selectEl'],
+                afterRender: function() {
+                    me.fontSelect = this.selectEl;
+                    Ext.Component.prototype.afterRender.apply(this, arguments);
+                },
+                onDisable: function() {
+                    var selectEl = this.selectEl;
+                    if (selectEl) {
+                        selectEl.dom.disabled = true;
+                    }
+                    Ext.Component.prototype.onDisable.apply(this, arguments);
+                },
+                onEnable: function() {
+                    var selectEl = this.selectEl;
+                    if (selectEl) {
+                        selectEl.dom.disabled = false;
+                    }
+                    Ext.Component.prototype.onEnable.apply(this, arguments);
+                },
+                listeners: {
+                    change: function() {
+                        me.relayCmd('fontname', me.fontSelect.dom.value);
+                        me.deferFocus();
+                    },
+                    element: 'selectEl'
+                }
+            });
+
+            items.push(
+                fontSelectItem,
+                '-'
+            );
+        }
+
+        if (me.enableFormat) {
+            items.push(
+                btn('bold'),
+                btn('italic'),
+                btn('underline')
+            );
+        }
+
+        if (me.enableFontSize) {
+            items.push(
+                '-',
+                btn('increasefontsize', false, me.adjustFont),
+                btn('decreasefontsize', false, me.adjustFont)
+            );
+        }
+
+        if (me.enableColors) {
+            items.push(
+                '-', {
+                    itemId: 'forecolor',
+                    cls: baseCSSPrefix + 'btn-icon',
+                    iconCls: baseCSSPrefix + 'edit-forecolor',
+                    overflowText: editor.buttonTips.forecolor.title,
+                    tooltip: tipsEnabled ? editor.buttonTips.forecolor || undef : undef,
+                    tabIndex:-1,
+                    menu : Ext.widget('menu', {
+                        plain: true,
+                        items: [{
+                            xtype: 'colorpicker',
+                            allowReselect: true,
+                            focus: Ext.emptyFn,
+                            value: '000000',
+                            plain: true,
+                            clickEvent: 'mousedown',
+                            handler: function(cp, color) {
+                                me.execCmd('forecolor', Ext.isWebKit || Ext.isIE ? '#'+color : color);
+                                me.deferFocus();
+                                this.up('menu').hide();
+                            }
+                        }]
+                    })
+                }, {
+                    itemId: 'backcolor',
+                    cls: baseCSSPrefix + 'btn-icon',
+                    iconCls: baseCSSPrefix + 'edit-backcolor',
+                    overflowText: editor.buttonTips.backcolor.title,
+                    tooltip: tipsEnabled ? editor.buttonTips.backcolor || undef : undef,
+                    tabIndex:-1,
+                    menu : Ext.widget('menu', {
+                        plain: true,
+                        items: [{
+                            xtype: 'colorpicker',
+                            focus: Ext.emptyFn,
+                            value: 'FFFFFF',
+                            plain: true,
+                            allowReselect: true,
+                            clickEvent: 'mousedown',
+                            handler: function(cp, color) {
+                                if (Ext.isGecko) {
+                                    me.execCmd('useCSS', false);
+                                    me.execCmd('hilitecolor', color);
+                                    me.execCmd('useCSS', true);
+                                    me.deferFocus();
+                                } else {
+                                    me.execCmd(Ext.isOpera ? 'hilitecolor' : 'backcolor', Ext.isWebKit || Ext.isIE ? '#'+color : color);
+                                    me.deferFocus();
+                                }
+                                this.up('menu').hide();
+                            }
+                        }]
+                    })
+                }
+            );
+        }
+
+        if (me.enableAlignments) {
+            items.push(
+                '-',
+                btn('justifyleft'),
+                btn('justifycenter'),
+                btn('justifyright')
+            );
+        }
+
+        if (!Ext.isSafari2) {
+            if (me.enableLinks) {
+                items.push(
+                    '-',
+                    btn('createlink', false, me.createLink)
+                );
+            }
+
+            if (me.enableLists) {
+                items.push(
+                    '-',
+                    btn('insertorderedlist'),
+                    btn('insertunorderedlist')
+                );
+            }
+            if (me.enableSourceEdit) {
+                items.push(
+                    '-',
+                    btn('sourceedit', true, function(btn){
+                        me.toggleSourceEdit(!me.sourceEditMode);
+                    })
+                );
+            }
+        }
+        
+        
+        for (i = 0; i < items.length; i++) {
+            if (items[i].itemId !== 'sourceedit') {
+                items[i].disabled = true;
+            }
+        }
+
+        
+        
+        toolbar = Ext.widget('toolbar', {
+            id: me.id + '-toolbar',
+            ownerCt: me,
+            cls: Ext.baseCSSPrefix + 'html-editor-tb',
+            enableOverflow: true,
+            items: items,
+            ownerLayout: me.getComponentLayout(),
+
+            
+            listeners: {
+                click: function(e){
+                    e.preventDefault();
+                },
+                element: 'el'
+            }
+        });
+
+        me.toolbar = toolbar;
+    },
+    
+    getMaskTarget: function(){
+        return this.bodyEl;    
+    },
+
+    
+    setReadOnly: function(readOnly) {
+        var me = this,
+            textareaEl = me.textareaEl,
+            iframeEl = me.iframeEl,
+            body;
+
+        me.readOnly = readOnly;
+
+        if (textareaEl) {
+            textareaEl.dom.readOnly = readOnly;
+        }
+
+        if (me.initialized) {
+            body = me.getEditorBody();
+            if (Ext.isIE) {
+                
+                iframeEl.setDisplayed(false);
+                body.contentEditable = !readOnly;
+                iframeEl.setDisplayed(true);
+            } else {
+                me.setDesignMode(!readOnly);
+            }
+            if (body) {
+                body.style.cursor = readOnly ? 'default' : 'text';
+            }
+            me.disableItems(readOnly);
+        }
+    },
+
+    
+    getDocMarkup: function() {
+        var me = this,
+            h = me.iframeEl.getHeight() - me.iframePad * 2;
+        return Ext.String.format('<html><head><style type="text/css">body{border:0;margin:0;padding:{0}px;height:{1}px;box-sizing: border-box; -moz-box-sizing: border-box; -webkit-box-sizing: border-box;cursor:text}</style></head><body></body></html>', me.iframePad, h);
+    },
+
+    
+    getEditorBody: function() {
+        var doc = this.getDoc();
+        return doc.body || doc.documentElement;
+    },
+
+    
+    getDoc: function() {
+        return (!Ext.isIE && this.iframeEl.dom.contentDocument) || this.getWin().document;
+    },
+
+    
+    getWin: function() {
+        return Ext.isIE ? this.iframeEl.dom.contentWindow : window.frames[this.iframeEl.dom.name];
+    },
+
+    
+    
+    finishRenderChildren: function () {
+        this.callParent();
+        this.toolbar.finishRender();
+    },
+
+    
+    onRender: function() {
+        var me = this;
+
+        me.callParent(arguments);
+
+        
+        
+        me.inputEl = me.iframeEl;
+
+        
+        me.monitorTask = Ext.TaskManager.start({
+            run: me.checkDesignMode,
+            scope: me,
+            interval: 100
+        });
+    },
+
+    initRenderTpl: function() {
+        var me = this;
+        if (!me.hasOwnProperty('renderTpl')) {
+            me.renderTpl = me.getTpl('labelableRenderTpl');
+        }
+        return me.callParent();
+    },
+
+    initRenderData: function() {
+        this.beforeSubTpl = '<div class="' + this.editorWrapCls + '">' + Ext.DomHelper.markup(this.toolbar.getRenderTree());
+        return Ext.applyIf(this.callParent(), this.getLabelableRenderData());
+    },
+
+    getSubTplData: function() {
+        return {
+            $comp       : this,
+            cmpId       : this.id,
+            id          : this.getInputId(),
+            textareaCls : Ext.baseCSSPrefix + 'hidden',
+            value       : this.value,
+            iframeName  : Ext.id(),
+            iframeSrc   : Ext.SSL_SECURE_URL,
+            size        : 'height:100px;width:100%'
+        };
+    },
+
+    getSubTplMarkup: function() {
+        return this.getTpl('fieldSubTpl').apply(this.getSubTplData());
+    },
+
+    initFrameDoc: function() {
+        var me = this,
+            doc, task;
+
+        Ext.TaskManager.stop(me.monitorTask);
+
+        doc = me.getDoc();
+        me.win = me.getWin();
+
+        doc.open();
+        doc.write(me.getDocMarkup());
+        doc.close();
+
+        task = { 
+            run: function() {
+                var doc = me.getDoc();
+                if (doc.body || doc.readyState === 'complete') {
+                    Ext.TaskManager.stop(task);
+                    me.setDesignMode(true);
+                    Ext.defer(me.initEditor, 10, me);
+                }
+            },
+            interval : 10,
+            duration:10000,
+            scope: me
+        };
+        Ext.TaskManager.start(task);
+    },
+
+    checkDesignMode: function() {
+        var me = this,
+            doc = me.getDoc();
+        if (doc && (!doc.editorInitialized || me.getDesignMode() !== 'on')) {
+            me.initFrameDoc();
+        }
+    },
+
+    
+    setDesignMode: function(mode) {
+        var me = this,
+            doc = me.getDoc();
+        if (doc) {
+            if (me.readOnly) {
+                mode = false;
+            }
+            doc.designMode = (/on|true/i).test(String(mode).toLowerCase()) ?'on':'off';
+        }
+    },
+
+    
+    getDesignMode: function() {
+        var doc = this.getDoc();
+        return !doc ? '' : String(doc.designMode).toLowerCase();
+    },
+
+    disableItems: function(disabled) {
+        var items = this.getToolbar().items.items,
+            i,
+            iLen  = items.length,
+            item;
+
+        for (i = 0; i < iLen; i++) {
+            item = items[i];
+
+            if (item.getItemId() !== 'sourceedit') {
+                item.setDisabled(disabled);
+            }
+        }
+    },
+
+    
+    toggleSourceEdit: function(sourceEditMode) {
+        var me = this,
+            iframe = me.iframeEl,
+            textarea = me.textareaEl,
+            hiddenCls = Ext.baseCSSPrefix + 'hidden',
+            btn = me.getToolbar().getComponent('sourceedit');
+
+        if (!Ext.isBoolean(sourceEditMode)) {
+            sourceEditMode = !me.sourceEditMode;
+        }
+        me.sourceEditMode = sourceEditMode;
+
+        if (btn.pressed !== sourceEditMode) {
+            btn.toggle(sourceEditMode);
+        }
+        if (sourceEditMode) {
+            me.disableItems(true);
+            me.syncValue();
+            iframe.addCls(hiddenCls);
+            textarea.removeCls(hiddenCls);
+            textarea.dom.removeAttribute('tabIndex');
+            textarea.focus();
+            me.inputEl = textarea;
+        }
+        else {
+            if (me.initialized) {
+                me.disableItems(me.readOnly);
+            }
+            me.pushValue();
+            iframe.removeCls(hiddenCls);
+            textarea.addCls(hiddenCls);
+            textarea.dom.setAttribute('tabIndex', -1);
+            me.deferFocus();
+            me.inputEl = iframe;
+        }
+        me.fireEvent('editmodechange', me, sourceEditMode);
+        me.updateLayout();
+    },
+
+    
+    createLink : function() {
+        var url = prompt(this.createLinkText, this.defaultLinkValue);
+        if (url && url !== 'http:/'+'/') {
+            this.relayCmd('createlink', url);
+        }
+    },
+
+    clearInvalid: Ext.emptyFn,
+
+    
+    setValue: function(value) {
+        var me = this,
+            textarea = me.textareaEl;
+        me.mixins.field.setValue.call(me, value);
+        if (value === null || value === undefined) {
+            value = '';
+        }
+        if (textarea) {
+            textarea.dom.value = value;
+        }
+        me.pushValue();
+        return this;
+    },
+
+    
+    cleanHtml: function(html) {
+        html = String(html);
+        if (Ext.isWebKit) { 
+            html = html.replace(/\sclass="(?:Apple-style-span|khtml-block-placeholder)"/gi, '');
+        }
+
+        
+        if (html.charCodeAt(0) === parseInt(this.defaultValue.replace(/\D/g, ''), 10)) {
+            html = html.substring(1);
+        }
+        return html;
+    },
+
+    
+    syncValue : function(){
+        var me = this,
+            body, changed, html, bodyStyle, match;
+
+        if (me.initialized) {
+            body = me.getEditorBody();
+            html = body.innerHTML;
+            if (Ext.isWebKit) {
+                bodyStyle = body.getAttribute('style'); 
+                match = bodyStyle.match(/text-align:(.*?);/i);
+                if (match && match[1]) {
+                    html = '<div style="' + match[0] + '">' + html + '</div>';
+                }
+            }
+            html = me.cleanHtml(html);
+            if (me.fireEvent('beforesync', me, html) !== false) {
+                if (me.textareaEl.dom.value != html) {
+                    me.textareaEl.dom.value = html;
+                    changed = true;
+                }
+
+                me.fireEvent('sync', me, html);
+
+                if (changed) {
+                    
+                    
+                    me.checkChange();
+                }
+            }
+        }
+    },
+
+    
+    getValue : function() {
+        var me = this,
+            value;
+        if (!me.sourceEditMode) {
+            me.syncValue();
+        }
+        value = me.rendered ? me.textareaEl.dom.value : me.value;
+        me.value = value;
+        return value;
+    },
+
+    
+    pushValue: function() {
+        var me = this,
+            v;
+        if(me.initialized){
+            v = me.textareaEl.dom.value || '';
+            if (!me.activated && v.length < 1) {
+                v = me.defaultValue;
+            }
+            if (me.fireEvent('beforepush', me, v) !== false) {
+                me.getEditorBody().innerHTML = v;
+                if (Ext.isGecko) {
+                    
+                    me.setDesignMode(false);  
+                    me.setDesignMode(true);
+                }
+                me.fireEvent('push', me, v);
+            }
+        }
+    },
+
+    
+    deferFocus : function(){
+         this.focus(false, true);
+    },
+
+    getFocusEl: function() {
+        var me = this,
+            win = me.win;
+        return win && !me.sourceEditMode ? win : me.textareaEl;
+    },
+
+    
+    initEditor : function(){
+        
+        try {
+            var me = this,
+                dbody = me.getEditorBody(),
+                ss = me.textareaEl.getStyles('font-size', 'font-family', 'background-image', 'background-repeat', 'background-color', 'color'),
+                doc,
+                fn;
+
+            ss['background-attachment'] = 'fixed'; 
+            dbody.bgProperties = 'fixed'; 
+
+            Ext.DomHelper.applyStyles(dbody, ss);
+
+            doc = me.getDoc();
+
+            if (doc) {
+                try {
+                    Ext.EventManager.removeAll(doc);
+                } catch(e) {}
+            }
+
+            
+            fn = Ext.Function.bind(me.onEditorEvent, me);
+            Ext.EventManager.on(doc, {
+                mousedown: fn,
+                dblclick: fn,
+                click: fn,
+                keyup: fn,
+                buffer:100
+            });
+
+            
+            
+            
+            
+            
+            fn = me.onRelayedEvent;
+            Ext.EventManager.on(doc, {
+                mousedown: fn, 
+                mousemove: fn, 
+                mouseup: fn,   
+                click: fn,     
+                dblclick: fn,  
+                scope: me
+            });
+
+            if (Ext.isGecko) {
+                Ext.EventManager.on(doc, 'keypress', me.applyCommand, me);
+            }
+            if (me.fixKeys) {
+                Ext.EventManager.on(doc, 'keydown', me.fixKeys, me);
+            }
+
+            
+            Ext.EventManager.on(window, 'unload', me.beforeDestroy, me);
+            doc.editorInitialized = true;
+
+            me.initialized = true;
+            me.pushValue();
+            me.setReadOnly(me.readOnly);
+            me.fireEvent('initialize', me);
+        } catch(ex) {
+            
+        }
+    },
+
+    
+    beforeDestroy : function(){
+        var me = this,
+            monitorTask = me.monitorTask,
+            doc, prop;
+
+        if (monitorTask) {
+            Ext.TaskManager.stop(monitorTask);
+        }
+        if (me.rendered) {
+            try {
+                doc = me.getDoc();
+                if (doc) {
+                    
+                    
+                    
+                    
+                    
+                    Ext.EventManager.removeAll(Ext.fly(doc));
+                    for (prop in doc) {
+                        if (doc.hasOwnProperty && doc.hasOwnProperty(prop)) {
+                            delete doc[prop];
+                        }
+                    }
+                }
+            } catch(e) {
+                
+            }
+            Ext.destroyMembers(me, 'toolbar', 'iframeEl', 'textareaEl');
+        }
+        me.callParent();
+    },
+
+    
+    onRelayedEvent: function (event) {
+        
+
+        var iframeEl = this.iframeEl,
+            iframeXY = iframeEl.getXY(),
+            eventXY = event.getXY();
+
+        
+        
+        event.xy = [iframeXY[0] + eventXY[0], iframeXY[1] + eventXY[1]];
+
+        event.injectEvent(iframeEl); 
+
+        event.xy = eventXY; 
+    },
+
+    
+    onFirstFocus : function(){
+        var me = this,
+            selection, range;
+        me.activated = true;
+        me.disableItems(me.readOnly);
+        if (Ext.isGecko) { 
+            me.win.focus();
+            selection = me.win.getSelection();
+            if (!selection.focusNode || selection.focusNode.nodeType !== 3) {
+                range = selection.getRangeAt(0);
+                range.selectNodeContents(me.getEditorBody());
+                range.collapse(true);
+                me.deferFocus();
+            }
+            try {
+                me.execCmd('useCSS', true);
+                me.execCmd('styleWithCSS', false);
+            } catch(e) {
+                
+            }
+        }
+        me.fireEvent('activate', me);
+    },
+
+    
+    adjustFont: function(btn) {
+        var adjust = btn.getItemId() === 'increasefontsize' ? 1 : -1,
+            size = this.getDoc().queryCommandValue('FontSize') || '2',
+            isPxSize = Ext.isString(size) && size.indexOf('px') !== -1,
+            isSafari;
+        size = parseInt(size, 10);
+        if (isPxSize) {
+            
+            
+            if (size <= 10) {
+                size = 1 + adjust;
+            }
+            else if (size <= 13) {
+                size = 2 + adjust;
+            }
+            else if (size <= 16) {
+                size = 3 + adjust;
+            }
+            else if (size <= 18) {
+                size = 4 + adjust;
+            }
+            else if (size <= 24) {
+                size = 5 + adjust;
+            }
+            else {
+                size = 6 + adjust;
+            }
+            size = Ext.Number.constrain(size, 1, 6);
+        } else {
+            isSafari = Ext.isSafari;
+            if (isSafari) { 
+                adjust *= 2;
+            }
+            size = Math.max(1, size + adjust) + (isSafari ? 'px' : 0);
+        }
+        this.execCmd('FontSize', size);
+    },
+
+    
+    onEditorEvent: function(e) {
+        this.updateToolbar();
+    },
+
+    
+    updateToolbar: function() {
+        var me = this,
+            btns, doc, name, fontSelect;
+
+        if (me.readOnly) {
+            return;
+        }
+
+        if (!me.activated) {
+            me.onFirstFocus();
+            return;
+        }
+
+        btns = me.getToolbar().items.map;
+        doc = me.getDoc();
+
+        if (me.enableFont && !Ext.isSafari2) {
+            name = (doc.queryCommandValue('FontName') || me.defaultFont).toLowerCase();
+            fontSelect = me.fontSelect.dom;
+            if (name !== fontSelect.value) {
+                fontSelect.value = name;
+            }
+        }
+
+        function updateButtons() {
+            for (var i = 0, l = arguments.length, name; i < l; i++) {
+                name = arguments[i];
+                btns[name].toggle(doc.queryCommandState(name));
+            }
+        }
+        if(me.enableFormat){
+            updateButtons('bold', 'italic', 'underline');
+        }
+        if(me.enableAlignments){
+            updateButtons('justifyleft', 'justifycenter', 'justifyright');
+        }
+        if(!Ext.isSafari2 && me.enableLists){
+            updateButtons('insertorderedlist', 'insertunorderedlist');
+        }
+
+        Ext.menu.Manager.hideAll();
+
+        me.syncValue();
+    },
+
+    
+    relayBtnCmd: function(btn) {
+        this.relayCmd(btn.getItemId());
+    },
+
+    
+    relayCmd: function(cmd, value) {
+        Ext.defer(function() {
+            var me = this;
+            me.focus();
+            me.execCmd(cmd, value);
+            me.updateToolbar();
+        }, 10, this);
+    },
+
+    
+    execCmd : function(cmd, value){
+        var me = this,
+            doc = me.getDoc(),
+            undef;
+        doc.execCommand(cmd, false, value === undef ? null : value);
+        me.syncValue();
+    },
+
+    
+    applyCommand : function(e){
+        if (e.ctrlKey) {
+            var me = this,
+                c = e.getCharCode(), cmd;
+            if (c > 0) {
+                c = String.fromCharCode(c);
+                switch (c) {
+                    case 'b':
+                        cmd = 'bold';
+                    break;
+                    case 'i':
+                        cmd = 'italic';
+                    break;
+                    case 'u':
+                        cmd = 'underline';
+                    break;
+                }
+                if (cmd) {
+                    me.win.focus();
+                    me.execCmd(cmd);
+                    me.deferFocus();
+                    e.preventDefault();
+                }
+            }
+        }
+    },
+
+    
+    insertAtCursor : function(text){
+        var me = this,
+            range;
+
+        if (me.activated) {
+            me.win.focus();
+            if (Ext.isIE) {
+                range = me.getDoc().selection.createRange();
+                if (range) {
+                    range.pasteHTML(text);
+                    me.syncValue();
+                    me.deferFocus();
+                }
+            }else{
+                me.execCmd('InsertHTML', text);
+                me.deferFocus();
+            }
+        }
+    },
+
+    
+    fixKeys: (function() { 
+        if (Ext.isIE) {
+            return function(e){
+                var me = this,
+                    k = e.getKey(),
+                    doc = me.getDoc(),
+                    readOnly = me.readOnly,
+                    range, target;
+
+                if (k === e.TAB) {
+                    e.stopEvent();
+                    if (!readOnly) {
+                        range = doc.selection.createRange();
+                        if(range){
+                            range.collapse(true);
+                            range.pasteHTML('&#160;&#160;&#160;&#160;');
+                            me.deferFocus();
+                        }
+                    }
+                }
+                else if (k === e.ENTER) {
+                    if (!readOnly) {
+                        range = doc.selection.createRange();
+                        if (range) {
+                            target = range.parentElement();
+                            if(!target || target.tagName.toLowerCase() !== 'li'){
+                                e.stopEvent();
+                                range.pasteHTML('<br />');
+                                range.collapse(false);
+                                range.select();
+                            }
+                        }
+                    }
+                }
+            };
+        }
+
+        if (Ext.isOpera) {
+            return function(e){
+                var me = this;
+                if (e.getKey() === e.TAB) {
+                    e.stopEvent();
+                    if (!me.readOnly) {
+                        me.win.focus();
+                        me.execCmd('InsertHTML','&#160;&#160;&#160;&#160;');
+                        me.deferFocus();
+                    }
+                }
+            };
+        }
+
+        if (Ext.isWebKit) {
+            return function(e){
+                var me = this,
+                    k = e.getKey(),
+                    readOnly = me.readOnly;
+
+                if (k === e.TAB) {
+                    e.stopEvent();
+                    if (!readOnly) {
+                        me.execCmd('InsertText','\t');
+                        me.deferFocus();
+                    }
+                }
+                else if (k === e.ENTER) {
+                    e.stopEvent();
+                    if (!readOnly) {
+                        me.execCmd('InsertHtml','<br /><br />');
+                        me.deferFocus();
+                    }
+                }
+            };
+        }
+
+        return null; 
+    }()),
+
+    
+    getToolbar : function(){
+        return this.toolbar;
+    },
+
+    
+    
+    buttonTips : {
+        bold : {
+            title: 'Bold (Ctrl+B)',
+            text: 'Make the selected text bold.',
+            cls: Ext.baseCSSPrefix + 'html-editor-tip'
+        },
+        italic : {
+            title: 'Italic (Ctrl+I)',
+            text: 'Make the selected text italic.',
+            cls: Ext.baseCSSPrefix + 'html-editor-tip'
+        },
+        underline : {
+            title: 'Underline (Ctrl+U)',
+            text: 'Underline the selected text.',
+            cls: Ext.baseCSSPrefix + 'html-editor-tip'
+        },
+        increasefontsize : {
+            title: 'Grow Text',
+            text: 'Increase the font size.',
+            cls: Ext.baseCSSPrefix + 'html-editor-tip'
+        },
+        decreasefontsize : {
+            title: 'Shrink Text',
+            text: 'Decrease the font size.',
+            cls: Ext.baseCSSPrefix + 'html-editor-tip'
+        },
+        backcolor : {
+            title: 'Text Highlight Color',
+            text: 'Change the background color of the selected text.',
+            cls: Ext.baseCSSPrefix + 'html-editor-tip'
+        },
+        forecolor : {
+            title: 'Font Color',
+            text: 'Change the color of the selected text.',
+            cls: Ext.baseCSSPrefix + 'html-editor-tip'
+        },
+        justifyleft : {
+            title: 'Align Text Left',
+            text: 'Align text to the left.',
+            cls: Ext.baseCSSPrefix + 'html-editor-tip'
+        },
+        justifycenter : {
+            title: 'Center Text',
+            text: 'Center text in the editor.',
+            cls: Ext.baseCSSPrefix + 'html-editor-tip'
+        },
+        justifyright : {
+            title: 'Align Text Right',
+            text: 'Align text to the right.',
+            cls: Ext.baseCSSPrefix + 'html-editor-tip'
+        },
+        insertunorderedlist : {
+            title: 'Bullet List',
+            text: 'Start a bulleted list.',
+            cls: Ext.baseCSSPrefix + 'html-editor-tip'
+        },
+        insertorderedlist : {
+            title: 'Numbered List',
+            text: 'Start a numbered list.',
+            cls: Ext.baseCSSPrefix + 'html-editor-tip'
+        },
+        createlink : {
+            title: 'Hyperlink',
+            text: 'Make the selected text a hyperlink.',
+            cls: Ext.baseCSSPrefix + 'html-editor-tip'
+        },
+        sourceedit : {
+            title: 'Source Edit',
+            text: 'Switch to source editing mode.',
+            cls: Ext.baseCSSPrefix + 'html-editor-tip'
+        }
+    }
+    
+
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+});
+
+
+Ext.define('Ext.form.field.Radio', {
+    extend:'Ext.form.field.Checkbox',
+    alias: ['widget.radiofield', 'widget.radio'],
+    alternateClassName: 'Ext.form.Radio',
+    requires: ['Ext.form.RadioManager'],
+
+    
+    isRadio: true,
+
+    
+
+    
+    inputType: 'radio',
+    ariaRole: 'radio',
+    
+    formId: null,
+
+    
+    getGroupValue: function() {
+        var selected = this.getManager().getChecked(this.name, this.getFormId());
+        return selected ? selected.inputValue : null;
+    },
+
+    
+    onBoxClick: function(e) {
+        var me = this;
+        if (!me.disabled && !me.readOnly) {
+            this.setValue(true);
+        }
+    },
+    
+    onRemoved: function(){
+        this.callParent(arguments);
+        this.formId = null;
+    },
+
+    
+    setValue: function(v) {
+        var me = this,
+            active;
+
+        if (Ext.isBoolean(v)) {
+            me.callParent(arguments);
+        } else {
+            active = me.getManager().getWithValue(me.name, v, me.getFormId()).getAt(0);
+            if (active) {
+                active.setValue(true);
+            }
+        }
+        return me;
+    },
+
+    
+    getSubmitValue: function() {
+        return this.checked ? this.inputValue : null;
+    },
+
+    getModelData: function() {
+        return this.getSubmitData();
+    },
+
+    
+    onChange: function(newVal, oldVal) {
+        var me = this,
+            r, rLen, radio, radios;
+
+        me.callParent(arguments);
+
+        if (newVal) {
+            radios = me.getManager().getByName(me.name, me.getFormId()).items;
+            rLen   = radios.length;
+
+            for (r = 0; r < rLen; r++) {
+                radio = radios[r];
+
+                if (radio !== me) {
+                    radio.setValue(false);
+                }
+            }
+        }
+    },
+
+    
+    getManager: function() {
+        return Ext.form.RadioManager;
+    }
+});
+
+
+Ext.define('Ext.picker.Time', {
+    extend: 'Ext.view.BoundList',
+    alias: 'widget.timepicker',
+    requires: ['Ext.data.Store', 'Ext.Date'],
+
+    
+
+    
+
+    
+    increment: 15,
+
+    
+    
+    format : "g:i A",
+    
+
+    
+    displayField: 'disp',
+
+    
+    initDate: [2008,0,1],
+
+    componentCls: Ext.baseCSSPrefix + 'timepicker',
+
+    
+    loadMask: false,
+
+    initComponent: function() {
+        var me = this,
+            dateUtil = Ext.Date,
+            clearTime = dateUtil.clearTime,
+            initDate = me.initDate;
+
+        
+        me.absMin = clearTime(new Date(initDate[0], initDate[1], initDate[2]));
+        me.absMax = dateUtil.add(clearTime(new Date(initDate[0], initDate[1], initDate[2])), 'mi', (24 * 60) - 1);
+
+        me.store = me.createStore();
+        me.updateList();
+
+        me.callParent();
+    },
+
+    
+    setMinValue: function(value) {
+        this.minValue = value;
+        this.updateList();
+    },
+
+    
+    setMaxValue: function(value) {
+        this.maxValue = value;
+        this.updateList();
+    },
+
+    
+    normalizeDate: function(date) {
+        var initDate = this.initDate;
+        date.setFullYear(initDate[0], initDate[1], initDate[2]);
+        return date;
+    },
+
+    
+    updateList: function() {
+        var me = this,
+            min = me.normalizeDate(me.minValue || me.absMin),
+            max = me.normalizeDate(me.maxValue || me.absMax);
+
+        me.store.filterBy(function(record) {
+            var date = record.get('date');
+            return date >= min && date <= max;
+        });
+    },
+
+    
+    createStore: function() {
+        var me = this,
+            utilDate = Ext.Date,
+            times = [],
+            min = me.absMin,
+            max = me.absMax;
+
+        while(min <= max){
+            times.push({
+                disp: utilDate.dateFormat(min, me.format),
+                date: min
+            });
+            min = utilDate.add(min, 'mi', me.increment);
+        }
+
+        return new Ext.data.Store({
+            fields: ['disp', 'date'],
+            data: times
+        });
+    }
+
+});
+
+
+Ext.define('Ext.form.field.Time', {
+    extend:'Ext.form.field.ComboBox',
+    alias: 'widget.timefield',
+    requires: ['Ext.form.field.Date', 'Ext.picker.Time', 'Ext.view.BoundListKeyNav', 'Ext.Date'],
+    alternateClassName: ['Ext.form.TimeField', 'Ext.form.Time'],
+
+    
+    triggerCls: Ext.baseCSSPrefix + 'form-time-trigger',
+
+    
+
+    
+
+    
+    
+    minText : "The time in this field must be equal to or after {0}",
+    
+
+    
+    
+    maxText : "The time in this field must be equal to or before {0}",
+    
+
+    
+    
+    invalidText : "{0} is not a valid time",
+    
+
+    
+    
+    format : "g:i A",
+    
+
+    
+    
+    
+
+    
+    
+    altFormats : "g:ia|g:iA|g:i a|g:i A|h:i|g:i|H:i|ga|ha|gA|h a|g a|g A|gi|hi|gia|hia|g|H|gi a|hi a|giA|hiA|gi A|hi A",
+    
+
+    
+    increment: 15,
+
+    
+    pickerMaxHeight: 300,
+
+    
+    selectOnTab: true,
+    
+    
+    snapToIncrement: false,
+
+    
+    initDate: '1/1/2008',
+    initDateFormat: 'j/n/Y',
+    
+    ignoreSelection: 0,
+
+    queryMode: 'local',
+
+    displayField: 'disp',
+
+    valueField: 'date',
+
+    initComponent: function() {
+        var me = this,
+            min = me.minValue,
+            max = me.maxValue;
+        if (min) {
+            me.setMinValue(min);
+        }
+        if (max) {
+            me.setMaxValue(max);
+        }
+        me.displayTpl = new Ext.XTemplate(
+            '<tpl for=".">' +
+                '{[typeof values === "string" ? values : this.formatDate(values["' + me.displayField + '"])]}' +
+                '<tpl if="xindex < xcount">' + me.delimiter + '</tpl>' +
+            '</tpl>', {
+            formatDate: Ext.Function.bind(me.formatDate, me)
+        });
+        this.callParent();
+    },
+
+    
+    transformOriginalValue: function(value) {
+        if (Ext.isString(value)) {
+            return this.rawToValue(value);
+        }
+        return value;
+    },
+
+    
+    isEqual: function(v1, v2) {
+        return Ext.Date.isEqual(v1, v2);
+    },
+
+    
+    setMinValue: function(value) {
+        var me = this,
+            picker = me.picker;
+        me.setLimit(value, true);
+        if (picker) {
+            picker.setMinValue(me.minValue);
+        }
+    },
+
+    
+    setMaxValue: function(value) {
+        var me = this,
+            picker = me.picker;
+        me.setLimit(value, false);
+        if (picker) {
+            picker.setMaxValue(me.maxValue);
+        }
+    },
+
+    
+    setLimit: function(value, isMin) {
+        var me = this,
+            d, val;
+        if (Ext.isString(value)) {
+            d = me.parseDate(value);
+        }
+        else if (Ext.isDate(value)) {
+            d = value;
+        }
+        if (d) {
+            val = Ext.Date.clearTime(new Date(me.initDate));
+            val.setHours(d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds());
+        }
+        
+        else {
+            val = null;
+        }
+        me[isMin ? 'minValue' : 'maxValue'] = val;
+    },
+
+    rawToValue: function(rawValue) {
+        return this.parseDate(rawValue) || rawValue || null;
+    },
+
+    valueToRaw: function(value) {
+        return this.formatDate(this.parseDate(value));
+    },
+
+    
+    getErrors: function(value) {
+        var me = this,
+            format = Ext.String.format,
+            errors = me.callParent(arguments),
+            minValue = me.minValue,
+            maxValue = me.maxValue,
+            date;
+
+        value = me.formatDate(value || me.processRawValue(me.getRawValue()));
+
+        if (value === null || value.length < 1) { 
+             return errors;
+        }
+
+        date = me.parseDate(value);
+        if (!date) {
+            errors.push(format(me.invalidText, value, Ext.Date.unescapeFormat(me.format)));
+            return errors;
+        }
+
+        if (minValue && date < minValue) {
+            errors.push(format(me.minText, me.formatDate(minValue)));
+        }
+
+        if (maxValue && date > maxValue) {
+            errors.push(format(me.maxText, me.formatDate(maxValue)));
+        }
+
+        return errors;
+    },
+
+    formatDate: function() {
+        return Ext.form.field.Date.prototype.formatDate.apply(this, arguments);
+    },
+
+    
+    parseDate: function(value) {
+        var me = this,
+            val = value,
+            altFormats = me.altFormats,
+            altFormatsArray = me.altFormatsArray,
+            i = 0,
+            len;
+
+        if (value && !Ext.isDate(value)) {
+            val = me.safeParse(value, me.format);
+
+            if (!val && altFormats) {
+                altFormatsArray = altFormatsArray || altFormats.split('|');
+                len = altFormatsArray.length;
+                for (; i < len && !val; ++i) {
+                    val = me.safeParse(value, altFormatsArray[i]);
+                }
+            }
+        }
+
+        
+        if (val && me.snapToIncrement) {
+            val = new Date(Ext.Number.snap(val.getTime(), me.increment * 60 * 1000));
+        }
+        return val;
+    },
+
+    safeParse: function(value, format){
+        var me = this,
+            utilDate = Ext.Date,
+            parsedDate,
+            result = null;
+
+        if (utilDate.formatContainsDateInfo(format)) {
+            
+            result = utilDate.parse(value, format);
+        } else {
+            
+            parsedDate = utilDate.parse(me.initDate + ' ' + value, me.initDateFormat + ' ' + format);
+            if (parsedDate) {
+                result = parsedDate;
+            }
+        }
+        return result;
+    },
+
+    
+    getSubmitValue: function() {
+        var me = this,
+            format = me.submitFormat || me.format,
+            value = me.getValue();
+
+        return value ? Ext.Date.format(value, format) : null;
+    },
+
+    
+    createPicker: function() {
+        var me = this,
+            picker;
+
+        me.listConfig = Ext.apply({
+            xtype: 'timepicker',
+            selModel: {
+                mode: 'SINGLE'
+            },
+            cls: undefined,
+            minValue: me.minValue,
+            maxValue: me.maxValue,
+            increment: me.increment,
+            format: me.format,
+            maxHeight: me.pickerMaxHeight
+        }, me.listConfig);
+        picker = me.callParent();
+        me.store = picker.store;
+        return picker;
+    },
+    
+    onItemClick: function(picker, record){
+        
+        var me = this,
+            selected = picker.getSelectionModel().getSelection();
+
+        if (selected.length > 0) {
+            selected = selected[0];
+            if (selected && Ext.Date.isEqual(record.get('date'), selected.get('date'))) {
+                me.collapse();
+            }
+        }
+    },
+
+    
+    onListSelectionChange: function(list, recordArray) {
+        var me = this,
+            record = recordArray[0],
+            val = record ? record.get('date') : null;
+            
+        if (!me.ignoreSelection) {
+            me.skipSync = true;
+            me.setValue(val);
+            me.skipSync = false;
+            me.fireEvent('select', me, val);
+            me.picker.clearHighlight();
+            me.collapse();
+            me.inputEl.focus();
+        }
+    },
+    
+    
+    syncSelection: function() {
+        var me = this,
+            picker = me.picker,
+            toSelect,
+            selModel,
+            value,
+            data, d, dLen, rec;
+            
+        if (picker && !me.skipSync) {
+            picker.clearHighlight();
+            value = me.getValue();
+            selModel = picker.getSelectionModel();
+            
+            me.ignoreSelection++;
+            if (value === null) {
+                selModel.deselectAll();
+            } else if(Ext.isDate(value)) {
+                
+                data = picker.store.data.items;
+                dLen = data.length;
+
+                for (d = 0; d < dLen; d++) {
+                    rec = data[d];
+
+                    if (Ext.Date.isEqual(rec.get('date'), value)) {
+                       toSelect = rec;
+                       break;
+                   }
+                }
+
+                selModel.select(toSelect);
+            }
+            me.ignoreSelection--;
+        }
+    },
+
+    postBlur: function() {
+        var me = this;
+
+        me.callParent(arguments);
+        me.setRawValue(me.formatDate(me.getValue()));
+    },
+
+    setValue: function() {
+
+        
+        this.getPicker();
+
+        this.callParent(arguments);
+    },
+
+    getValue: function() {
+        return this.parseDate(this.callParent(arguments));
+    }
+});
+
+
+Ext.define('Ext.grid.CellEditor', {
+    extend: 'Ext.Editor',
+    constructor: function(config) {
+        config = Ext.apply({}, config);
+        
+        if (config.field) {
+            config.field.monitorTab = false;
+        }
+        this.callParent([config]);
+    },
+    
+    
+    onShow: function() {
+        var me = this,
+            innerCell = me.boundEl.first(),
+            lastChild,
+            textNode;
+
+        if (innerCell) {
+            lastChild = innerCell.dom.lastChild;
+            if(lastChild && lastChild.nodeType === 3) {
+                
+                textNode = me.cellTextNode = innerCell.dom.lastChild;
+                
+                me.cellTextValue = textNode.nodeValue;
+                
+                
+                textNode.nodeValue = '\u00a0';
+            }
+        }
+        me.callParent(arguments);
+    },
+
+    
+    onHide: function() {
+        var me = this,
+            innerCell = me.boundEl.first();
+
+        if (innerCell && me.cellTextNode) {
+            me.cellTextNode.nodeValue = me.cellTextValue;
+            delete me.cellTextNode;
+            delete me.cellTextValue;
+        }
+        me.callParent(arguments);
+    },
+
+    
+    afterRender: function() {
+        var me = this,
+            field = me.field;
+
+        me.callParent(arguments);
+        if (field.isXType('checkboxfield')) {
+            field.mon(field.inputEl, {
+                mousedown: me.onCheckBoxMouseDown,
+                click: me.onCheckBoxClick,
+                scope: me
+            });
+        }
+    },
+    
+    
+    onCheckBoxMouseDown: function() {
+        this.completeEdit = Ext.emptyFn;
+    },
+    
+    
+    onCheckBoxClick: function() {
+        delete this.completeEdit;
+        this.field.focus(false, 10);
+    },
+    
+    
+    realign: function(autoSize) {
+        var me = this,
+            boundEl = me.boundEl,
+            innerCell = boundEl.first(),
+            children = innerCell.dom.childNodes,
+            childCount = children.length,
+            offsets = Ext.Array.clone(me.offsets),
+            inputEl = me.field.inputEl,
+            lastChild, leftBound, rightBound, width;
+
+        
+        
+        
+        
+        
+        if(me.isForTree && (childCount > 1 || (childCount === 1 && children[0].nodeType !== 3))) {
+            
+            lastChild = innerCell.last();
+            
+            leftBound = lastChild.getOffsetsTo(innerCell)[0] + lastChild.getWidth();
+            
+            
+            
+            rightBound = innerCell.getWidth();
+            
+            
+            width = rightBound - leftBound;
+            
+            
+            if(!me.editingPlugin.grid.columnLines) {
+                width --;
+            }
+            
+            offsets[0] += leftBound;
+
+            me.addCls(Ext.baseCSSPrefix + 'grid-editor-on-text-node');
+        } else {
+            width = boundEl.getWidth() - 1;
+        }
+
+        if (autoSize === true) {
+            me.field.setWidth(width);
+        }
+
+        me.alignTo(boundEl, me.alignment, offsets);
+    },
+    
+    onEditorTab: function(e){
+        var field = this.field;
+        if (field.onEditorTab) {
+            field.onEditorTab(e);
+        }
+    },
+
+    alignment: "tl-tl",
+    hideEl : false,
+    cls: Ext.baseCSSPrefix + "small-editor " + Ext.baseCSSPrefix + "grid-editor",
+    shim: false,
+    shadow: false
+});
+
+
+Ext.define('Ext.grid.ColumnComponentLayout', {
+    extend: 'Ext.layout.component.Auto',
+    alias: 'layout.columncomponent',
+
+    type: 'columncomponent',
+
+    setWidthInDom: true,
+
+    getContentHeight : function(ownerContext) {
+        
+        return this.owner.isGroupHeader ? ownerContext.getProp('contentHeight') : this.callParent(arguments);
+    },
+
+    calculateOwnerHeightFromContentHeight: function (ownerContext, contentHeight) {
+        var result = this.callParent(arguments);
+        if (this.owner.isGroupHeader) {
+            result += this.owner.titleEl.dom.offsetHeight;
+        }
+        return result;
+    },
+    
+    getContentWidth : function(ownerContext) {
+        
+        return this.owner.isGroupHeader ? ownerContext.getProp('contentWidth') : this.callParent(arguments);
+    },
+
+    calculateOwnerWidthFromContentWidth: function (ownerContext, contentWidth) {
+        return contentWidth + ownerContext.getPaddingInfo().width;
+    }
+});
+
+
+Ext.define('Ext.grid.ColumnLayout', {
+    extend: 'Ext.layout.container.HBox',
+    alias: 'layout.gridcolumn',
+    type : 'gridcolumn',
+
+    reserveOffset: false,
+
+    firstHeaderCls: Ext.baseCSSPrefix + 'column-header-first',
+    lastHeaderCls: Ext.baseCSSPrefix + 'column-header-last',
+
+    initLayout: function() {
+        this.grid = this.owner.up('[scrollerOwner]');
+        this.callParent();
+    },
+
+    
+    beginLayout: function (ownerContext) {
+        var me = this,
+            grid = me.grid,
+            view = grid.view,
+            i = 0,
+            items = me.getVisibleItems(),
+            len = items.length,
+            item;
+
+        ownerContext.gridContext = ownerContext.context.getCmp(me.grid);
+
+        
+        
+        
+        if (grid.lockable) {
+            if (me.owner.up('tablepanel') === view.normalGrid) {
+                view = view.normalGrid.getView();
+            } else {
+                view = null;
+            }
+        }
+
+        me.callParent(arguments);
+
+        
+        for (; i < len; i++) {
+            item = items[i];
+            item.removeCls([me.firstHeaderCls, me.lastHeaderCls]);
+            item.el.setStyle({
+                height: 'auto'
+            });
+            item.titleEl.setStyle({
+                height: 'auto',
+                paddingTop: ''  
+            });
+        }
+
+        
+        if (len > 0) {
+            items[0].addCls(me.firstHeaderCls);
+            items[len - 1].addCls(me.lastHeaderCls);
+        }
+
+        
+        
+        
+        if (!me.owner.isHeader && Ext.getScrollbarSize().width && !grid.collapsed && view &&
+                view.table.dom && (view.autoScroll || view.overflowY)) {
+            ownerContext.viewContext = ownerContext.context.getCmp(view);
+        }
+    },
+
+    roundFlex: function(width) {
+        return Math.floor(width);
+    },
+
+    calculate: function(ownerContext) {
+        var me = this,
+            viewContext = ownerContext.viewContext,
+            tableHeight,
+            viewHeight;
+
+        me.callParent(arguments);
+
+        if (ownerContext.state.parallelDone) {
+            ownerContext.setProp('columnWidthsDone', true);
+        }
+
+        
+        
+        
+        
+        if (viewContext && !ownerContext.state.overflowAdjust.width && !ownerContext.gridContext.heightModel.shrinkWrap) {
+            tableHeight = viewContext.tableContext.getProp('height');
+            viewHeight = viewContext.getProp('height');
+
+            
+            if (isNaN(tableHeight + viewHeight)) {
+                me.done = false;
+            }
+
+            
+            else if (tableHeight >= viewHeight) {
+                ownerContext.gridContext.invalidate({
+                    after: function() {
+                        ownerContext.state.overflowAdjust = {
+                            width: Ext.getScrollbarSize().width,
+                            height: 0
+                        };
+                    }
+                });
+            }
+        }
+    },
+ 
+    completeLayout: function(ownerContext) {
+        var me = this,
+            owner = me.owner,
+            state = ownerContext.state,
+            needsInvalidate = false,
+            calculated = me.sizeModels.calculated,
+            childItems, len, i, childContext, item;
+
+        me.callParent(arguments);
+
+        
+        
+        
+        if (!state.flexesCalculated && owner.forceFit && !owner.isHeader) {
+            childItems = ownerContext.childItems;
+            len = childItems.length;
+
+            for (i = 0; i < len; i++) {
+                childContext = childItems[i];
+                item = childContext.target;
+
+                
+                
+                if (item.width) {
+                    item.flex = ownerContext.childItems[i].flex = item.width;
+                    delete item.width;
+                    childContext.widthModel = calculated;
+                    needsInvalidate = true;
+                }
+            }
+
+            
+            
+            if (needsInvalidate) {
+                me.cacheFlexes(ownerContext);
+                ownerContext.invalidate({
+                    state: {
+                        flexesCalculated: true
+                    }
+                });
+            }
+        }
+    },
+
+    finalizeLayout: function() {
+        var me = this,
+            i = 0,
+            items,
+            len,
+            itemsHeight,
+            owner = me.owner,
+            titleEl = owner.titleEl;
+
+        
+        items = me.getVisibleItems();
+        len = items.length;
+        
+        itemsHeight = owner.el.getViewSize().height;
+        if (titleEl) {
+        
+        
+            itemsHeight -= titleEl.getHeight();
+        }
+        for (; i < len; i++) {
+            items[i].setPadding(itemsHeight);
+        }
+    },
+
+    
+    
+    publishInnerCtSize: function(ownerContext) {
+        var me = this,
+            size = ownerContext.state.boxPlan.targetSize,
+            cw = ownerContext.peek('contentWidth'),
+            view;
+
+        
+        if ((cw != null) && !me.owner.isHeader) {
+            size.width = cw;
+
+            
+            view = me.owner.ownerCt.view;
+            if (view.autoScroll || view.overflowY) {
+                size.width += Ext.getScrollbarSize().width;
+            }
+        }
+
+        return me.callParent(arguments);
+    }
+});
+
+
+Ext.define('Ext.grid.LockingView', {
+
+    mixins: {
+        observable: 'Ext.util.Observable'
+    },
+
+    eventRelayRe: /^(beforeitem|beforecontainer|item|container|cell)/,
+
+    constructor: function(config){
+        var me = this,
+            eventNames = [],
+            eventRe = me.eventRelayRe,
+            locked = config.locked.getView(),
+            normal = config.normal.getView(),
+            events,
+            event;
+
+        Ext.apply(me, {
+            lockedView: locked,
+            normalView: normal,
+            lockedGrid: config.locked,
+            normalGrid: config.normal,
+            panel: config.panel
+        });
+        me.mixins.observable.constructor.call(me, config);
+
+        
+        events = locked.events;
+        for (event in events) {
+            if (events.hasOwnProperty(event) && eventRe.test(event)) {
+                eventNames.push(event);
+            }
+        }
+        me.relayEvents(locked, eventNames);
+        me.relayEvents(normal, eventNames);
+
+        normal.on({
+            scope: me,
+            itemmouseleave: me.onItemMouseLeave,
+            itemmouseenter: me.onItemMouseEnter
+        });
+
+        locked.on({
+            scope: me,
+            itemmouseleave: me.onItemMouseLeave,
+            itemmouseenter: me.onItemMouseEnter
+        });
+    },
+
+    getGridColumns: function() {
+        var cols = this.lockedGrid.headerCt.getGridColumns();
+        return cols.concat(this.normalGrid.headerCt.getGridColumns());
+    },
+
+    getEl: function(column){
+        return this.getViewForColumn(column).getEl();
+    },
+
+    getViewForColumn: function(column) {
+        var view = this.lockedView,
+            inLocked;
+
+        view.headerCt.cascade(function(col){
+            if (col === column) {
+                inLocked = true;
+                return false;
+            }
+        });
+
+        return inLocked ? view : this.normalView;
+    },
+
+    onItemMouseEnter: function(view, record){
+        var me = this,
+            locked = me.lockedView,
+            other = me.normalView,
+            item;
+
+        if (view.trackOver) {
+            if (view !== locked) {
+                other = locked;
+            }
+            item = other.getNode(record);
+            other.highlightItem(item);
+        }
+    },
+
+    onItemMouseLeave: function(view, record){
+        var me = this,
+            locked = me.lockedView,
+            other = me.normalView;
+
+        if (view.trackOver) {
+            if (view !== locked) {
+                other = locked;
+            }
+            other.clearHighlight();
+        }
+    },
+
+    relayFn: function(name, args){
+        args = args || [];
+
+        var view = this.lockedView;
+        view[name].apply(view, args || []);
+        view = this.normalView;
+        view[name].apply(view, args || []);
+    },
+
+    getSelectionModel: function(){
+        return this.panel.getSelectionModel();
+    },
+
+    getStore: function(){
+        return this.panel.store;
+    },
+
+    getNode: function(nodeInfo){
+        
+        return this.normalView.getNode(nodeInfo);
+    },
+
+    getCell: function(record, column){
+        var view = this.getViewForColumn(column),
+            row;
+
+        row = view.getNode(record);
+        return Ext.fly(row).down(column.getCellSelector());
+    },
+
+    getRecord: function(node){
+        var result = this.lockedView.getRecord(node);
+        if (!node) {
+            result = this.normalView.getRecord(node);
+        }
+        return result;
+    },
+
+    addElListener: function(eventName, fn, scope){
+        this.relayFn('addElListener', arguments);
+    },
+
+    refreshNode: function(){
+        this.relayFn('refreshNode', arguments);
+    },
+
+    refresh: function(){
+        this.relayFn('refresh', arguments);
+    },
+
+    bindStore: function(){
+        this.relayFn('bindStore', arguments);
+    },
+
+    addRowCls: function(){
+        this.relayFn('addRowCls', arguments);
+    },
+
+    removeRowCls: function(){
+        this.relayFn('removeRowCls', arguments);
+    }
+
+});
+
+
+Ext.define('Ext.view.TableLayout', {
+    extend: 'Ext.layout.component.Auto',
+
+    alias: ['layout.tableview'],
+    type: 'tableview',
+
+    beginLayout: function(ownerContext) {
+        var me = this;
+
+        me.callParent(arguments);
+
+        
+        if (me.owner.table.dom) {
+            ownerContext.tableContext = ownerContext.getEl(me.owner.table);
+
+            
+            ownerContext.headerContext = ownerContext.context.getCmp(me.headerCt);
+        }
+    },
+
+    calculate: function(ownerContext) {
+        var me = this;
+
+        me.callParent(arguments);
+
+        if (ownerContext.tableContext) {
+            if (ownerContext.state.columnWidthsSynced) {
+                if (ownerContext.hasProp('columnWidthsFlushed')) {
+                    ownerContext.tableContext.setHeight(ownerContext.tableContext.el.dom.offsetHeight, false);
+                } else {
+                    me.done = false;
+                }
+            } else {
+                if (ownerContext.headerContext.hasProp('columnWidthsDone')) {
+                    ownerContext.context.queueFlush(me);
+                    ownerContext.state.columnWidthsSynced = true;
+                }
+
+                
+                
+                
+                me.done = false;
+            }
+        }
+    },
+
+    measureContentHeight: function(ownerContext) {
+        
+        if (!ownerContext.headerContext || ownerContext.hasProp('columnWidthsFlushed')) {
+            return this.callParent(arguments);
+        }
+    },
+
+    flush: function() {
+        var me = this,
+            context = me.ownerContext.context,
+            columns = me.headerCt.getGridColumns(),
+            i = 0, len = columns.length,
+            el = me.owner.el,
+            tableWidth = 0,
+            colWidth;
+
+        
+        context.currentLayout = me;
+
+        
+        for (i = 0; i < len; i++) {
+            colWidth = columns[i].hidden ? 0 : context.getCmp(columns[i]).props.width;
+            tableWidth += colWidth;
+
+            
+            
+            
+            el.select(me.getColumnSelector(columns[i])).setWidth(colWidth);
+        }
+        el.select('table.' + Ext.baseCSSPrefix + 'grid-table-resizer').setWidth(tableWidth);
+
+        
+        me.ownerContext.setProp('columnWidthsFlushed', true);
+    },
+    
+    finishedLayout: function(){
+        var me = this,
+            first;
+            
+        me.callParent(arguments);   
+        
+        
+        
+        if (Ext.isGecko) {
+            first = me.headerCt.getGridColumns()[0];
+            if (first) {
+                first = me.owner.el.down(me.getColumnSelector(first));
+                if (first) {
+                    first.setStyle('display', 'none');
+                    first.dom.scrollWidth;
+                    first.setStyle('display', '');
+                }
+            }
+        } 
+    },
+
+    getColumnSelector: function(column) {
+        return 'th.' + Ext.baseCSSPrefix + 'grid-col-resizer-' + column.id;
+    }
+});
+
+
+Ext.define('Ext.view.Table', {
+    extend: 'Ext.view.View',
+    alias: 'widget.tableview',
+    uses: [
+        'Ext.view.TableLayout',
+        'Ext.view.TableChunker',
+        'Ext.util.DelayedTask',
+        'Ext.util.MixedCollection'
+    ],
+
+    componentLayout: 'tableview',
+
+    baseCls: Ext.baseCSSPrefix + 'grid-view',
+
+    
+    itemSelector: 'tr.' + Ext.baseCSSPrefix + 'grid-row',
+    
+    cellSelector: 'td.' + Ext.baseCSSPrefix + 'grid-cell',
+
+    
+    rowSelector: 'tr.' + Ext.baseCSSPrefix + 'grid-row',
+
+    
+    firstCls: Ext.baseCSSPrefix + 'grid-cell-first',
+
+    
+    lastCls: Ext.baseCSSPrefix + 'grid-cell-last',
+
+    headerRowSelector: 'tr.' + Ext.baseCSSPrefix + 'grid-header-row',
+
+    selectedItemCls: Ext.baseCSSPrefix + 'grid-row-selected',
+    selectedCellCls: Ext.baseCSSPrefix + 'grid-cell-selected',
+    focusedItemCls: Ext.baseCSSPrefix + 'grid-row-focused',
+    overItemCls: Ext.baseCSSPrefix + 'grid-row-over',
+    altRowCls:   Ext.baseCSSPrefix + 'grid-row-alt',
+    rowClsRe: new RegExp('(?:^|\\s*)' + Ext.baseCSSPrefix + 'grid-row-(first|last|alt)(?:\\s+|$)', 'g'),
+    cellRe: new RegExp(Ext.baseCSSPrefix + 'grid-cell-([^\\s]+) ', ''),
+
+    
+    trackOver: true,
+
+    
+    getRowClass: null,
+
+    
+    stripeRows: true,
+    
+    
+    markDirty : true,
+
+    
+
+    
+    initialTpl: '<div></div>',
+
+    initComponent: function() {
+        var me = this,
+            scroll = me.scroll;
+
+        
+        me.table = new Ext.dom.Element.Fly();
+        me.table.id = me.id + 'gridTable';
+
+        
+        
+        me.autoScroll = undefined;
+
+        
+        if (scroll === true || scroll === 'both') {
+            me.autoScroll = true;
+        } else if (scroll === 'horizontal') {
+            me.overflowX = 'auto';
+        } else if (scroll === 'vertical') {
+            me.overflowY = 'auto';
+        }
+        me.selModel.view = me;
+        me.headerCt.view = me;
+        me.headerCt.markDirty = me.markDirty;
+
+        
+        me.initFeatures(me.grid);
+        delete me.grid;
+
+        
+        me.tpl = me.getTpl('initialTpl');
+        me.callParent();
+    },
+    
+    
+    moveColumn: function(fromIdx, toIdx, colsToMove) {
+        var me = this,
+            fragment = (colsToMove > 1) ? document.createDocumentFragment() : undefined,
+            destinationCellIdx = toIdx,
+            colCount = me.getGridColumns().length,
+            lastIdx = colCount - 1,
+            doFirstLastClasses = (me.firstCls || me.lastCls) && (toIdx === 0 || toIdx == colCount || fromIdx === 0 || fromIdx == lastIdx),
+            i,
+            j,
+            rows, len, tr, headerRows;
+
+        if (me.rendered) {
+            
+            
+            headerRows = me.el.query(me.headerRowSelector);
+            rows = me.el.query(me.rowSelector);
+
+            if (toIdx > fromIdx && fragment) {
+                destinationCellIdx -= colsToMove;
+            }
+
+            
+            for (i = 0, len = headerRows.length; i < len; ++i) {
+                tr = headerRows[i];
+                if (fragment) {
+                    for (j = 0; j < colsToMove; j++) {
+                        fragment.appendChild(tr.cells[fromIdx]);
+                    }
+                    tr.insertBefore(fragment, tr.cells[destinationCellIdx] || null);
+                } else {
+                    tr.insertBefore(tr.cells[fromIdx], tr.cells[destinationCellIdx] || null);
+                }
+            }
+
+            for (i = 0, len = rows.length; i < len; i++) {
+                tr = rows[i];
+
+                
+                if (doFirstLastClasses) {
+
+                    if (fromIdx === 0) {
+                        Ext.fly(tr.cells[0]).removeCls(me.firstCls);
+                        Ext.fly(tr.cells[1]).addCls(me.firstCls);
+                    } else if (fromIdx === lastIdx) {
+                        Ext.fly(tr.cells[lastIdx]).removeCls(me.lastCls);
+                        Ext.fly(tr.cells[lastIdx - 1]).addCls(me.lastCls);
+                    }
+                    if (toIdx === 0) {
+                        Ext.fly(tr.cells[0]).removeCls(me.firstCls);
+                        Ext.fly(tr.cells[fromIdx]).addCls(me.firstCls);
+                    } else if (toIdx === colCount) {
+                        Ext.fly(tr.cells[lastIdx]).removeCls(me.lastCls);
+                        Ext.fly(tr.cells[fromIdx]).addCls(me.lastCls);
+                    }
+                }
+
+                if (fragment) {
+                    for (j = 0; j < colsToMove; j++) {
+                        fragment.appendChild(tr.cells[fromIdx]);
+                    }
+                    tr.insertBefore(fragment, tr.cells[destinationCellIdx] || null);
+                } else {
+                    tr.insertBefore(tr.cells[fromIdx], tr.cells[destinationCellIdx] || null);
+                }
+            }
+            me.setNewTemplate();
+        }
+    },
+
+    
+    scrollToTop: Ext.emptyFn,
+
+    
+    addElListener: function(eventName, fn, scope){
+        this.mon(this, eventName, fn, scope, {
+            element: 'el'
+        });
+    },
+
+    
+    getGridColumns: function() {
+        return this.headerCt.getGridColumns();
+    },
+
+    
+    getHeaderAtIndex: function(index) {
+        return this.headerCt.getHeaderAtIndex(index);
+    },
+
+    
+    getCell: function(record, column) {
+        var row = this.getNode(record);
+        return Ext.fly(row).down(column.getCellSelector());
+    },
+
+    
+    getFeature: function(id) {
+        var features = this.featuresMC;
+        if (features) {
+            return features.get(id);
+        }
+    },
+
+    
+    initFeatures: function(grid) {
+        var me = this,
+            i,
+            features,
+            feature,
+            len;
+
+        me.featuresMC = new Ext.util.MixedCollection();
+        features = me.features = me.constructFeatures();
+        len = features ? features.length : 0;
+        for (i = 0; i < len; i++) {
+            feature = features[i];
+
+            
+            feature.view = me;
+            feature.grid = grid;
+            me.featuresMC.add(feature);
+            feature.init();
+        }
+    },
+
+    
+    constructFeatures: function() {
+        var me = this,
+            features = me.features,
+            feature,
+            result,
+            i = 0, len;
+        
+        if (features) {
+            result = [];
+            len = features.length;
+            for (; i < len; i++) {
+                feature = features[i];
+                if (!feature.isFeature) {
+                    feature = Ext.create('feature.' + feature.ftype, feature);
+                }
+                result[i] = feature;
+            }
+        }
+        return result;
+    },
+
+    
+    attachEventsForFeatures: function() {
+        var features = this.features,
+            ln       = features.length,
+            i        = 0;
+
+        for (; i < ln; i++) {
+            if (features[i].isFeature) {
+                features[i].attachEvents();
+            }
+        }
+    },
+
+    afterRender: function() {
+        var me = this;
+        me.callParent();
+
+        if (!me.enableTextSelection) {
+            me.el.unselectable();
+        }
+        me.attachEventsForFeatures();
+    },
+
+    
+    onViewScroll: function(e, t) {
+        this.callParent(arguments);
+        this.fireEvent('bodyscroll', e, t);
+    },
+
+    
+    prepareData: function(data, idx, record) {
+        var me       = this,
+            result   = me.headerCt.prepareData(data, idx, record, me, me.ownerCt),
+            features = me.features,
+            ln       = features.length,
+            i        = 0,
+            feature;
+
+        for (; i < ln; i++) {
+            feature = features[i];
+            if (feature.isFeature) {
+                Ext.apply(result, feature.getAdditionalData(data, idx, record, result, me));
+            }
+        }
+
+        return result;
+    },
+
+    
+    collectData: function(records, startIndex) {
+        var me = this,
+            preppedRecords = me.callParent(arguments),
+            headerCt  = me.headerCt,
+            fullWidth = headerCt.getFullWidth(),
+            features  = me.features,
+            ln = features.length,
+            o = {
+                rows: preppedRecords,
+                fullWidth: fullWidth
+            },
+            i  = 0,
+            feature,
+            j = 0,
+            jln,
+            rowParams,
+            rec,
+            cls;
+
+        jln = preppedRecords.length;
+        
+        
+        if (me.getRowClass) {
+            for (; j < jln; j++) {
+                rowParams = {};
+                rec = preppedRecords[j];
+                cls = rec.rowCls || '';
+                rec.rowCls = this.getRowClass(records[j], j, rowParams, me.store) + ' ' + cls;
+            }
+        }
+        
+        
+        for (; i < ln; i++) {
+            feature = features[i];
+            if (feature.isFeature && feature.collectData && !feature.disabled) {
+                o = feature.collectData(records, preppedRecords, startIndex, fullWidth, o);
+                break;
+            }
+        }
+        return o;
+    },
+
+    
+    
+    
+    
+    
+    
+    refreshSize: function() {
+        var me = this,
+            cmp;
+
+        
+        me.table.attach(me.el.child('table', true));
+
+        if (!me.hasLoadingHeight) {
+            cmp = me.up('tablepanel');
+
+            
+            
+            Ext.suspendLayouts();
+
+            me.callParent();
+
+            
+            
+            if (cmp && Ext.getScrollbarSize().width && (me.autoScroll || me.overflowY)) {
+                cmp.updateLayout();
+            }
+
+            Ext.resumeLayouts(true);
+        }
+    },
+
+    
+    setNewTemplate: function() {
+        var me = this,
+            columns = me.headerCt.getColumnsForTpl(true);
+
+        
+        me.tpl = me.getTableChunker().getTableTpl({
+            rowCount: me.store.getCount(),
+            columns: columns,
+            features: me.features,
+            enableTextSelection: me.enableTextSelection
+        });
+    },
+
+    
+    getTableChunker: function() {
+        return this.chunker || Ext.view.TableChunker;
+    },
+
+    
+    addRowCls: function(rowInfo, cls) {
+        var row = this.getNode(rowInfo);
+        if (row) {
+            Ext.fly(row).addCls(cls);
+        }
+    },
+
+    
+    removeRowCls: function(rowInfo, cls) {
+        var row = this.getNode(rowInfo);
+        if (row) {
+            Ext.fly(row).removeCls(cls);
+        }
+    },
+
+    
+    onRowSelect : function(rowIdx) {
+        this.addRowCls(rowIdx, this.selectedItemCls);
+    },
+
+    
+    onRowDeselect : function(rowIdx) {
+        var me = this;
+
+        me.removeRowCls(rowIdx, me.selectedItemCls);
+        me.removeRowCls(rowIdx, me.focusedItemCls);
+    },
+
+    onCellSelect: function(position) {
+        var cell = this.getCellByPosition(position, true);
+        if (cell) {
+            Ext.fly(cell).addCls(this.selectedCellCls);
+        }
+    },
+
+    onCellDeselect: function(position) {
+        var cell = this.getCellByPosition(position, true);
+        if (cell) {
+            Ext.fly(cell).removeCls(this.selectedCellCls);
+        }
+
+    },
+
+    onCellFocus: function(position) {
+        this.focusCell(position);
+    },
+
+    getCellByPosition: function(position, returnDom) {
+        if (position) {
+            var node   = this.getNode(position.row),
+                header = this.headerCt.getHeaderAtIndex(position.column);
+
+            if (header && node) {
+                return Ext.fly(node).down(header.getCellSelector(), returnDom);
+            }
+        }
+        return false;
+    },
+
+    
+    
+    onRowFocus: function(rowIdx, highlight, supressFocus) {
+        var me = this;
+
+        if (highlight) {
+            me.addRowCls(rowIdx, me.focusedItemCls);
+            if (!supressFocus) {
+                me.focusRow(rowIdx);
+            }
+            
+        } else {
+            me.removeRowCls(rowIdx, me.focusedItemCls);
+        }
+    },
+
+    
+    focusRow: function(rowIdx) {
+        var me         = this,
+            row        = me.getNode(rowIdx),
+            el         = me.el,
+            adjustment = 0,
+            panel      = me.ownerCt,
+            rowRegion,
+            elTop,
+            elBottom,
+            record;
+
+        if (row && el) {
+            
+            
+            elTop = el.getY();
+            elBottom = elTop + el.dom.clientHeight;
+            rowRegion = Ext.fly(row).getRegion();
+            
+            if (rowRegion.top < elTop) {
+                adjustment = rowRegion.top - elTop;
+            
+            } else if (rowRegion.bottom > elBottom) {
+                adjustment = rowRegion.bottom - elBottom;
+            }
+            record = me.getRecord(row);
+            rowIdx = me.store.indexOf(record);
+
+            if (adjustment) {
+                panel.scrollByDeltaY(adjustment);
+            }
+            me.fireEvent('rowfocus', record, row, rowIdx);
+        }
+    },
+
+    focusCell: function(position) {
+        var me          = this,
+            cell        = me.getCellByPosition(position),
+            el          = me.el,
+            adjustmentY = 0,
+            adjustmentX = 0,
+            elRegion    = el.getRegion(),
+            panel       = me.ownerCt,
+            cellRegion,
+            record;
+
+        
+        
+        elRegion.bottom = elRegion.top + el.dom.clientHeight;
+        elRegion.right = elRegion.left + el.dom.clientWidth;
+        if (cell) {
+            cellRegion = cell.getRegion();
+            
+            if (cellRegion.top < elRegion.top) {
+                adjustmentY = cellRegion.top - elRegion.top;
+            
+            } else if (cellRegion.bottom > elRegion.bottom) {
+                adjustmentY = cellRegion.bottom - elRegion.bottom;
+            }
+
+            
+            if (cellRegion.left < elRegion.left) {
+                adjustmentX = cellRegion.left - elRegion.left;
+            
+            } else if (cellRegion.right > elRegion.right) {
+                adjustmentX = cellRegion.right - elRegion.right;
+            }
+
+            if (adjustmentY) {
+                panel.scrollByDeltaY(adjustmentY);
+            }
+            if (adjustmentX) {
+                panel.scrollByDeltaX(adjustmentX);
+            }
+            el.focus();
+            me.fireEvent('cellfocus', record, cell, position);
+        }
+    },
+
+    
+    scrollByDelta: function(delta, dir) {
+        dir = dir || 'scrollTop';
+        var elDom = this.el.dom;
+        elDom[dir] = (elDom[dir] += delta);
+    },
+
+    
+    onUpdate : function(store, record, operation, changedFieldNames) {
+        var me = this,
+            index,
+            newRow, newAttrs, attLen, i, attName, oldRow, oldRowDom,
+            oldCells, newCells, len, i,
+            columns, overItemCls,
+            isHovered, row,
+            
+            isEditing = me.editingPlugin && me.editingPlugin.editing;
+
+        if (me.viewReady) {
+
+            index = me.store.indexOf(record);
+            columns = me.headerCt.getGridColumns();
+            overItemCls = me.overItemCls;
+
+            
+            
+            if (columns.length && index > -1) {
+                newRow = me.bufferRender([record], index)[0];
+                oldRow = me.all.item(index);
+                if (oldRow) {
+                    oldRowDom = oldRow.dom;
+                    isHovered = oldRow.hasCls(overItemCls);
+
+                    
+                    if (oldRowDom.mergeAttributes) {
+                        oldRowDom.mergeAttributes(newRow, true);
+                    } else {
+                        newAttrs = newRow.attributes;
+                        attLen = newAttrs.length;
+                        for (i = 0; i < attLen; i++) {
+                            attName = newAttrs[i].name;
+                            if (attName !== 'id') {
+                                oldRowDom.setAttribute(attName, newAttrs[i].value);
+                            }
+                        }
+                    }
+
+                    if (isHovered) {
+                        oldRow.addCls(overItemCls);
+                    }
+
+                    
+                    oldCells = oldRow.query(me.cellSelector);
+                    newCells = Ext.fly(newRow).query(me.cellSelector);
+                    len = newCells.length;
+                    
+                    row = oldCells[0].parentNode;
+                    for (i = 0; i < len; i++) {
+                        
+                        
+                        if (me.shouldUpdateCell(columns[i], changedFieldNames)) {
+                            
+                            if (isEditing) {
+                                Ext.fly(oldCells[i]).syncContent(newCells[i]);
+                            }
+                            
+                            else {
+                                row.insertBefore(newCells[i], oldCells[i]);
+                                row.removeChild(oldCells[i]);
+                            }
+                        }
+                    }
+                }
+                me.fireEvent('itemupdate', record, index, newRow);
+            }
+        }
+    },
+    
+    shouldUpdateCell: function(column, changedFieldNames){
+        
+        
+        if (column.hasCustomRenderer) {
+            return true;
+        }
+        return !changedFieldNames || Ext.Array.contains(changedFieldNames, column.dataIndex);
+    },
+
+    
+    refresh: function() {
+        var me = this;
+        me.setNewTemplate();
+        me.callParent(arguments);
+        me.doStripeRows(0);
+        me.headerCt.setSortState();
+    },
+
+    clearViewEl: function() {
+        this.callParent();
+        delete this.table.dom;
+    },
+
+    processItemEvent: function(record, row, rowIndex, e) {
+        var me = this,
+            cell = e.getTarget(me.cellSelector, row),
+            cellIndex = cell ? cell.cellIndex : -1,
+            map = me.statics().EventMap,
+            selModel = me.getSelectionModel(),
+            type = e.type,
+            result;
+
+        if (type == 'keydown' && !cell && selModel.getCurrentPosition) {
+            
+            cell = me.getCellByPosition(selModel.getCurrentPosition());
+            if (cell) {
+                cell = cell.dom;
+                cellIndex = cell.cellIndex;
+            }
+        }
+
+        result = me.fireEvent('uievent', type, me, cell, rowIndex, cellIndex, e, record, row);
+
+        if (result === false || me.callParent(arguments) === false) {
+            return false;
+        }
+
+        
+        if (type == 'mouseover' || type == 'mouseout') {
+            return true;
+        }
+
+        if(!cell) {
+            
+            
+            return true;
+        }
+
+        return !(
+            
+            (me['onBeforeCell' + map[type]](cell, cellIndex, record, row, rowIndex, e) === false) ||
+            (me.fireEvent('beforecell' + type, me, cell, cellIndex, record, row, rowIndex, e) === false) ||
+            (me['onCell' + map[type]](cell, cellIndex, record, row, rowIndex, e) === false) ||
+            (me.fireEvent('cell' + type, me, cell, cellIndex, record, row, rowIndex, e) === false)
+        );
+    },
+
+    processSpecialEvent: function(e) {
+        var me = this,
+            map = me.statics().EventMap,
+            features = me.features,
+            ln = features.length,
+            type = e.type,
+            i, feature, prefix, featureTarget,
+            beforeArgs, args,
+            panel = me.ownerCt;
+
+        me.callParent(arguments);
+
+        if (type == 'mouseover' || type == 'mouseout') {
+            return;
+        }
+
+        for (i = 0; i < ln; i++) {
+            feature = features[i];
+            if (feature.hasFeatureEvent) {
+                featureTarget = e.getTarget(feature.eventSelector, me.getTargetEl());
+                if (featureTarget) {
+                    prefix = feature.eventPrefix;
+                    
+                    
+                    beforeArgs = feature.getFireEventArgs('before' + prefix + type, me, featureTarget, e);
+                    args = feature.getFireEventArgs(prefix + type, me, featureTarget, e);
+
+                    if (
+                        
+                        (me.fireEvent.apply(me, beforeArgs) === false) ||
+                        
+                        (panel.fireEvent.apply(panel, beforeArgs) === false) ||
+                        
+                        (me.fireEvent.apply(me, args) === false) ||
+                        
+                        (panel.fireEvent.apply(panel, args) === false)
+                    ) {
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    },
+
+    onCellMouseDown: Ext.emptyFn,
+    onCellMouseUp: Ext.emptyFn,
+    onCellClick: Ext.emptyFn,
+    onCellDblClick: Ext.emptyFn,
+    onCellContextMenu: Ext.emptyFn,
+    onCellKeyDown: Ext.emptyFn,
+    onBeforeCellMouseDown: Ext.emptyFn,
+    onBeforeCellMouseUp: Ext.emptyFn,
+    onBeforeCellClick: Ext.emptyFn,
+    onBeforeCellDblClick: Ext.emptyFn,
+    onBeforeCellContextMenu: Ext.emptyFn,
+    onBeforeCellKeyDown: Ext.emptyFn,
+
+    
+    expandToFit: function(header) {
+        if (header) {
+            var maxWidth = this.getMaxContentWidth(header);
+            delete header.flex;
+            header.setWidth(maxWidth);
+        }
+    },
+
+    
+    getMaxContentWidth: function(header) {
+        var cellSelector = header.getCellInnerSelector(),
+            cells        = this.el.query(cellSelector),
+            i = 0,
+            ln = cells.length,
+            maxWidth = header.el.dom.scrollWidth,
+            scrollWidth;
+
+        for (; i < ln; i++) {
+            scrollWidth = cells[i].scrollWidth;
+            if (scrollWidth > maxWidth) {
+                maxWidth = scrollWidth;
+            }
+        }
+        return maxWidth;
+    },
+
+    getPositionByEvent: function(e) {
+        var me       = this,
+            cellNode = e.getTarget(me.cellSelector),
+            rowNode  = e.getTarget(me.itemSelector),
+            record   = me.getRecord(rowNode),
+            header   = me.getHeaderByCell(cellNode);
+
+        return me.getPosition(record, header);
+    },
+
+    getHeaderByCell: function(cell) {
+        if (cell) {
+            var m = cell.className.match(this.cellRe);
+            if (m && m[1]) {
+                return Ext.getCmp(m[1]);
+            }
+        }
+        return false;
+    },
+
+    
+    walkCells: function(pos, direction, e, preventWrap, verifierFn, scope) {
+
+        
+        
+        if (!pos) {
+            return;
+        }
+
+        var me       = this,
+            row      = pos.row,
+            column   = pos.column,
+            rowCount = me.store.getCount(),
+            firstCol = me.getFirstVisibleColumnIndex(),
+            lastCol  = me.getLastVisibleColumnIndex(),
+            newPos   = {row: row, column: column},
+            activeHeader = me.headerCt.getHeaderAtIndex(column);
+
+        
+        if (!activeHeader || activeHeader.hidden) {
+            return false;
+        }
+
+        e = e || {};
+        direction = direction.toLowerCase();
+        switch (direction) {
+            case 'right':
+                
+                if (column === lastCol) {
+                    
+                    if (preventWrap || row === rowCount - 1) {
+                        return false;
+                    }
+                    if (!e.ctrlKey) {
+                        
+                        newPos.row = row + 1;
+                        newPos.column = firstCol;
+                    }
+                
+                } else {
+                    if (!e.ctrlKey) {
+                        newPos.column = column + me.getRightGap(activeHeader);
+                    } else {
+                        newPos.column = lastCol;
+                    }
+                }
+                break;
+
+            case 'left':
+                
+                if (column === firstCol) {
+                    
+                    if (preventWrap || row === 0) {
+                        return false;
+                    }
+                    if (!e.ctrlKey) {
+                        
+                        newPos.row = row - 1;
+                        newPos.column = lastCol;
+                    }
+                
+                } else {
+                    if (!e.ctrlKey) {
+                        newPos.column = column + me.getLeftGap(activeHeader);
+                    } else {
+                        newPos.column = firstCol;
+                    }
+                }
+                break;
+
+            case 'up':
+                
+                if (row === 0) {
+                    return false;
+                
+                } else {
+                    if (!e.ctrlKey) {
+                        newPos.row = row - 1;
+                    } else {
+                        newPos.row = 0;
+                    }
+                }
+                break;
+
+            case 'down':
+                
+                if (row === rowCount - 1) {
+                    return false;
+                
+                } else {
+                    if (!e.ctrlKey) {
+                        newPos.row = row + 1;
+                    } else {
+                        newPos.row = rowCount - 1;
+                    }
+                }
+                break;
+        }
+
+        if (verifierFn && verifierFn.call(scope || window, newPos) !== true) {
+            return false;
+        } else {
+            return newPos;
+        }
+    },
+    getFirstVisibleColumnIndex: function() {
+        var firstVisibleHeader = this.getHeaderCt().getVisibleGridColumns()[0];
+
+        return firstVisibleHeader ? firstVisibleHeader.getIndex() : -1;
+    },
+
+    getLastVisibleColumnIndex: function() {
+        var visHeaders = this.getHeaderCt().getVisibleGridColumns(),
+            lastHeader = visHeaders[visHeaders.length - 1];
+
+        return lastHeader.getIndex();
+    },
+
+    getHeaderCt: function() {
+        return this.headerCt;
+    },
+
+    
+    getPosition: function(record, header) {
+        var me = this,
+            store = me.store,
+            gridCols = me.headerCt.getGridColumns();
+
+        return {
+            row: store.indexOf(record),
+            column: Ext.Array.indexOf(gridCols, header)
+        };
+    },
+
+    
+    getRightGap: function(activeHeader) {
+        var headerCt        = this.getHeaderCt(),
+            headers         = headerCt.getGridColumns(),
+            activeHeaderIdx = Ext.Array.indexOf(headers, activeHeader),
+            i               = activeHeaderIdx + 1,
+            nextIdx;
+
+        for (; i <= headers.length; i++) {
+            if (!headers[i].hidden) {
+                nextIdx = i;
+                break;
+            }
+        }
+
+        return nextIdx - activeHeaderIdx;
+    },
+
+    beforeDestroy: function() {
+        if (this.rendered) {
+            this.el.removeAllListeners();
+        }
+        this.callParent(arguments);
+    },
+
+    
+    getLeftGap: function(activeHeader) {
+        var headerCt        = this.getHeaderCt(),
+            headers         = headerCt.getGridColumns(),
+            activeHeaderIdx = Ext.Array.indexOf(headers, activeHeader),
+            i               = activeHeaderIdx - 1,
+            prevIdx;
+
+        for (; i >= 0; i--) {
+            if (!headers[i].hidden) {
+                prevIdx = i;
+                break;
+            }
+        }
+
+        return prevIdx - activeHeaderIdx;
+    },
+
+    
+    onAdd: function(ds, records, index) {
+        this.callParent(arguments);
+        this.doStripeRows(index);
+    },
+    
+    
+    onRemove: function(ds, records, index) {
+        this.callParent(arguments);
+        this.doStripeRows(index);
+    },
+    
+    
+    doStripeRows: function(startRow, endRow) {
+        var me = this,
+            rows,
+            rowsLn,
+            i,
+            row;
+            
+        
+        if (me.rendered && me.stripeRows) {
+            rows = me.getNodes(startRow, endRow);
+                
+            for (i = 0, rowsLn = rows.length; i < rowsLn; i++) {
+                row = rows[i];
+                
+                row.className = row.className.replace(me.rowClsRe, ' ');
+                startRow++;
+                
+                if (startRow % 2 === 0) {
+                    row.className += (' ' + me.altRowCls);
+                }
+            }
+        }
+    }
+ 
+});
+
+
+Ext.define('Ext.grid.Lockable', {
+
+    requires: [
+        'Ext.grid.LockingView',
+        'Ext.view.Table'
+    ],
+
+    
+    syncRowHeight: true,
+
+    
+
+    
+
+    
+
+    headerCounter: 0,
+
+    
+    scrollDelta: 40,
+    
+    
+    
+    
+
+    
+    
+    unlockText: 'Unlock',
+    
+    
+    lockText: 'Lock',
+    
+
+    determineXTypeToCreate: function() {
+        var me = this,
+            typeToCreate,
+            xtypes, xtypesLn, xtype, superxtype;
+
+        if (me.subGridXType) {
+            typeToCreate = me.subGridXType;
+        } else {
+            xtypes     = this.getXTypes().split('/');
+            xtypesLn   = xtypes.length;
+            xtype      = xtypes[xtypesLn - 1];
+            superxtype = xtypes[xtypesLn - 2];
+
+            if (superxtype !== 'tablepanel') {
+                typeToCreate = superxtype;
+            } else {
+                typeToCreate = xtype;
+            }
+        }
+
+        return typeToCreate;
+    },
+
+    
+    
+    injectLockable: function() {
+        
+        this.lockable = true;
+        
+        
+        this.hasView = true;
+
+        var me = this,
+            
+            scrollLocked = Ext.getScrollbarSize().width === 0,
+            store = me.store = Ext.StoreManager.lookup(me.store),
+            
+            
+            
+            xtype = me.determineXTypeToCreate(),
+            
+            selModel = me.getSelectionModel(),
+            lockedFeatures,
+            normalFeatures,
+            lockedPlugins,
+            normalPlugins,
+            lockedGrid,
+            normalGrid,
+            i, len,
+            columns,
+            lockedHeaderCt,
+            normalHeaderCt,
+            lockedView,
+            normalView,
+            listeners;
+
+        lockedFeatures = me.constructFeatures();
+
+        
+        me.cloneFeatures();
+        normalFeatures = me.constructFeatures();
+
+        lockedPlugins = me.constructPlugins();
+
+        
+        me.clonePlugins();
+        normalPlugins = me.constructPlugins();
+
+        
+        delete me.features;
+        delete me.plugins;
+
+        
+        for (i = 0, len = (lockedFeatures ? lockedFeatures.length : 0); i < len; i++) {
+            lockedFeatures[i].lockingPartner = normalFeatures[i];
+            normalFeatures[i].lockingPartner = lockedFeatures[i];
+        }
+
+        lockedGrid = Ext.apply({
+            xtype: xtype,
+            store: store,
+            scrollerOwner: false,
+            
+            enableAnimations: false,
+            scroll: scrollLocked ? 'vertical' : false,
+            selModel: selModel,
+            border: false,
+            cls: Ext.baseCSSPrefix + 'grid-inner-locked',
+            isLayoutRoot: function() {
+                return false;
+            },
+            features: lockedFeatures,
+            plugins: lockedPlugins
+        }, me.lockedGridConfig);
+
+        normalGrid = Ext.apply({
+            xtype: xtype,
+            store: store,
+            scrollerOwner: false,
+            enableAnimations: false,
+            selModel: selModel,
+            border: false,
+            isLayoutRoot: function() {
+                return false;
+            },
+            features: normalFeatures,
+            plugins: normalPlugins
+        }, me.normalGridConfig);
+
+        me.addCls(Ext.baseCSSPrefix + 'grid-locked');
+
+        
+        
+        
+        Ext.copyTo(normalGrid, me, me.bothCfgCopy);
+        Ext.copyTo(lockedGrid, me, me.bothCfgCopy);
+        Ext.copyTo(normalGrid, me, me.normalCfgCopy);
+        Ext.copyTo(lockedGrid, me, me.lockedCfgCopy);
+        for (i = 0; i < me.normalCfgCopy.length; i++) {
+            delete me[me.normalCfgCopy[i]];
+        }
+        for (i = 0; i < me.lockedCfgCopy.length; i++) {
+            delete me[me.lockedCfgCopy[i]];
+        }
+
+        me.addEvents(
+            
+            'lockcolumn',
+
+            
+            'unlockcolumn'
+        );
+
+        me.addStateEvents(['lockcolumn', 'unlockcolumn']);
+
+        me.lockedHeights = [];
+        me.normalHeights = [];
+
+        columns = me.processColumns(me.columns);
+
+        lockedGrid.width = columns.lockedWidth + Ext.num(selModel.headerWidth, 0);
+        lockedGrid.columns = columns.locked;
+        normalGrid.columns = columns.normal;
+
+        
+        normalGrid.flex = 1;
+        lockedGrid.viewConfig = me.lockedViewConfig || {};
+        lockedGrid.viewConfig.loadingUseMsg = false;
+        normalGrid.viewConfig = me.normalViewConfig || {};
+
+        Ext.applyIf(lockedGrid.viewConfig, me.viewConfig);
+        Ext.applyIf(normalGrid.viewConfig, me.viewConfig);
+
+        me.lockedGrid = Ext.ComponentManager.create(lockedGrid);
+        lockedView = me.lockedGrid.getView();
+        
+        normalGrid.viewConfig.lockingPartner = lockedView;
+        me.normalGrid = Ext.ComponentManager.create(normalGrid);
+        normalView = me.normalGrid.getView();
+
+        me.view = new Ext.grid.LockingView({
+            locked: me.lockedGrid,
+            normal: me.normalGrid,
+            panel: me
+        });
+
+        
+        listeners = {
+            scroll: {
+                fn: me.onLockedViewScroll,
+                element: 'el',
+                scope: me
+            }
+        };
+        
+        if (!scrollLocked) {
+            listeners.mousewheel = {
+                fn: me.onLockedViewMouseWheel,
+                element: 'el',
+                scope: me
+            };
+        }
+        if (me.syncRowHeight) {
+            listeners.refresh = me.onLockedViewRefresh;
+            listeners.itemupdate = me.onLockedViewItemUpdate;
+            listeners.scope = me;
+        }
+        lockedView.on(listeners);
+
+        
+        listeners = {
+            scroll: {
+                fn: me.onNormalViewScroll,
+                element: 'el',
+                scope: me
+            },
+            refresh: me.syncRowHeight ? me.onNormalViewRefresh : me.updateSpacer,
+            scope: me
+        };
+        normalView.on(listeners);
+
+        lockedHeaderCt = me.lockedGrid.headerCt;
+        normalHeaderCt = me.normalGrid.headerCt;
+
+        lockedHeaderCt.lockedCt = true;
+        lockedHeaderCt.lockableInjected = true;
+        normalHeaderCt.lockableInjected = true;
+
+        lockedHeaderCt.on({
+            columnshow: me.onLockedHeaderShow,
+            columnhide: me.onLockedHeaderHide,
+            columnmove: me.onLockedHeaderMove,
+            sortchange: me.onLockedHeaderSortChange,
+            columnresize: me.onLockedHeaderResize,
+            scope: me
+        });
+
+        normalHeaderCt.on({
+            columnmove: me.onNormalHeaderMove,
+            sortchange: me.onNormalHeaderSortChange,
+            scope: me
+        });
+
+        me.modifyHeaderCt();
+        me.items = [me.lockedGrid, me.normalGrid];
+
+        me.relayHeaderCtEvents(lockedHeaderCt);
+        me.relayHeaderCtEvents(normalHeaderCt);
+
+        me.layout = {
+            type: 'hbox',
+            align: 'stretch'
+        };
+    },
+
+    processColumns: function(columns){
+        
+        var i = 0,
+            len = columns.length,
+            lockedWidth = 0,
+            lockedHeaders = [],
+            normalHeaders = [],
+            column;
+
+        for (; i < len; ++i) {
+            column = columns[i];
+            
+            
+            if (!column.isComponent) {
+                column = Ext.apply({}, columns[i]);
+            }
+
+            
+            
+            column.processed = true;
+            if (column.locked) {
+                if (!column.hidden) {
+                    lockedWidth += column.width || Ext.grid.header.Container.prototype.defaultWidth;
+                }
+                lockedHeaders.push(column);
+            } else {
+                normalHeaders.push(column);
+            }
+            if (!column.headerId) {
+                column.headerId = (column.initialConfig || column).id || ('L' + (++this.headerCounter));
+            }
+        }
+        return {
+            lockedWidth: lockedWidth,
+            locked: {
+                items: lockedHeaders,
+                itemId: 'lockedHeaderCt',
+                stretchMaxPartner: '^^>>#normalHeaderCt'
+            },
+            normal: {
+                items: normalHeaders,
+                itemId: 'normalHeaderCt',
+                stretchMaxPartner: '^^>>#lockedHeaderCt'
+            }
+        };
+    },
+
+    
+    onLockedViewMouseWheel: function(e) {
+        var me = this,
+            scrollDelta = -me.scrollDelta,
+            deltaY = scrollDelta * e.getWheelDeltas().y,
+            vertScrollerEl = me.lockedGrid.getView().el.dom,
+            verticalCanScrollDown, verticalCanScrollUp;
+
+        if (vertScrollerEl) {
+            verticalCanScrollDown = vertScrollerEl.scrollTop !== vertScrollerEl.scrollHeight - vertScrollerEl.clientHeight;
+            verticalCanScrollUp   = vertScrollerEl.scrollTop !== 0;
+        }
+
+        if ((deltaY < 0 && verticalCanScrollUp) || (deltaY > 0 && verticalCanScrollDown)) {
+            e.stopEvent();
+
+            
+            
+            
+            me.scrolling = true;
+            vertScrollerEl.scrollTop += deltaY;
+            me.normalGrid.getView().el.dom.scrollTop = vertScrollerEl.scrollTop;
+            me.scrolling = false;
+
+            
+            me.onNormalViewScroll();
+        }
+    },
+
+    onLockedViewScroll: function() {
+        var me = this,
+            lockedView = me.lockedGrid.getView(),
+            normalView = me.normalGrid.getView(),
+            normalTable,
+            lockedTable;
+
+        
+        if (!me.scrolling) {
+            me.scrolling = true;
+            normalView.el.dom.scrollTop = lockedView.el.dom.scrollTop;
+    
+            
+            if (me.store.buffered) {
+                lockedTable = lockedView.el.child('table', true);
+                normalTable = normalView.el.child('table', true);
+                lockedTable.style.position = 'absolute';
+            }
+            me.scrolling = false;
+        }
+    },
+    
+    onNormalViewScroll: function() {
+        var me = this,
+            lockedView = me.lockedGrid.getView(),
+            normalView = me.normalGrid.getView(),
+            normalTable,
+            lockedTable;
+
+        
+        if (!me.scrolling) {
+            me.scrolling = true;
+            lockedView.el.dom.scrollTop = normalView.el.dom.scrollTop;
+    
+            
+            if (me.store.buffered) {
+                lockedTable = lockedView.el.child('table', true);
+                normalTable = normalView.el.child('table', true);
+                lockedTable.style.position = 'absolute';
+                lockedTable.style.top = normalTable.style.top;
+            }
+            me.scrolling = false;
+        }
+    },
+
+    
+    onLockedHeaderMove: function() {
+        if (this.syncRowHeight) {
+            this.onNormalViewRefresh();
+        }
+    },
+
+    
+    onNormalHeaderMove: function() {
+        if (this.syncRowHeight) {
+            this.onLockedViewRefresh();
+        }
+    },
+    
+    
+    
+    
+    
+    updateSpacer: function() {
+        var me   = this,
+            
+            
+            lockedViewEl   = me.lockedGrid.getView().el,
+            normalViewEl = me.normalGrid.getView().el.dom,
+            spacerId = lockedViewEl.dom.id + '-spacer',
+            spacerHeight = (normalViewEl.offsetHeight - normalViewEl.clientHeight) + 'px';
+
+        me.spacerEl = Ext.getDom(spacerId);
+        if (me.spacerEl) {
+            me.spacerEl.style.height = spacerHeight;
+        } else {
+            Ext.core.DomHelper.append(lockedViewEl, {
+                id: spacerId,
+                style: 'height: ' + spacerHeight
+            });
+        }
+    },
+
+    
+    onLockedViewRefresh: function() {
+
+        
+        if (this.normalGrid.headerCt.getGridColumns().length) {
+            var me     = this,
+                view   = me.lockedGrid.getView(),
+                el     = view.el,
+                rowEls = el.query(view.getItemSelector()),
+                ln     = rowEls.length,
+                i = 0;
+    
+            
+            me.lockedHeights = [];
+
+            for (; i < ln; i++) {
+                me.lockedHeights[i] = rowEls[i].offsetHeight;
+            }
+            me.syncRowHeights();
+            me.updateSpacer();
+        }
+    },
+
+    
+    onNormalViewRefresh: function() {
+
+        
+        if (this.lockedGrid.headerCt.getGridColumns().length) {
+            var me     = this,
+                view   = me.normalGrid.getView(),
+                el     = view.el,
+                rowEls = el.query(view.getItemSelector()),
+                ln     = rowEls.length,
+                i = 0;
+    
+            
+            me.normalHeights = [];
+    
+            for (; i < ln; i++) {
+                me.normalHeights[i] = rowEls[i].offsetHeight;
+            }
+            me.syncRowHeights();
+            me.updateSpacer();
+        }
+    },
+
+    
+    onLockedViewItemUpdate: function(record, index, node) {
+
+        
+        if (this.normalGrid.headerCt.getGridColumns().length) {
+            this.lockedHeights[index] = node.offsetHeight;
+            this.syncRowHeights();
+        }
+    },
+
+    
+    onNormalViewItemUpdate: function(record, index, node) {
+    
+        
+        if (this.lockedGrid.headerCt.getGridColumns().length) {
+            this.normalHeights[index] = node.offsetHeight;
+            this.syncRowHeights();
+        }
+    },
+
+    
+    syncRowHeights: function() {
+        var me = this,
+            lockedHeights = me.lockedHeights,
+            normalHeights = me.normalHeights,
+            ln = lockedHeights.length,
+            i  = 0,
+            lockedView, normalView,
+            lockedRowEls, normalRowEls,
+            scrollTop;
+
+        
+        
+        if (lockedHeights.length && normalHeights.length) {
+            lockedView = me.lockedGrid.getView();
+            normalView = me.normalGrid.getView();
+            lockedRowEls = lockedView.el.query(lockedView.getItemSelector());
+            normalRowEls = normalView.el.query(normalView.getItemSelector());
+
+            
+            for (; i < ln; i++) {
+                
+                if (!isNaN(lockedHeights[i]) && !isNaN(normalHeights[i])) {
+                    if (lockedHeights[i] > normalHeights[i]) {
+                        Ext.fly(normalRowEls[i]).setHeight(lockedHeights[i]);
+                    } else if (lockedHeights[i] < normalHeights[i]) {
+                        Ext.fly(lockedRowEls[i]).setHeight(normalHeights[i]);
+                    }
+                }
+            }
+
+            
+            scrollTop = normalView.el.dom.scrollTop;
+            normalView.el.dom.scrollTop = scrollTop;
+            lockedView.el.dom.scrollTop = scrollTop;
+            
+            
+            me.lockedHeights = [];
+            me.normalHeights = [];
+        }
+    },
+
+    
+    modifyHeaderCt: function() {
+        var me = this;
+        me.lockedGrid.headerCt.getMenuItems = me.getMenuItems(me.lockedGrid.headerCt.getMenuItems, true);
+        me.normalGrid.headerCt.getMenuItems = me.getMenuItems(me.normalGrid.headerCt.getMenuItems, false);
+    },
+
+    onUnlockMenuClick: function() {
+        this.unlock();
+    },
+
+    onLockMenuClick: function() {
+        this.lock();
+    },
+
+    getMenuItems: function(getMenuItems, locked) {
+        var me            = this,
+            unlockText    = me.unlockText,
+            lockText      = me.lockText,
+            unlockCls     = Ext.baseCSSPrefix + 'hmenu-unlock',
+            lockCls       = Ext.baseCSSPrefix + 'hmenu-lock',
+            unlockHandler = Ext.Function.bind(me.onUnlockMenuClick, me),
+            lockHandler   = Ext.Function.bind(me.onLockMenuClick, me);
+
+        
+        return function() {
+
+            
+            
+            var o = getMenuItems.call(this);
+            o.push('-', {
+                cls: unlockCls,
+                text: unlockText,
+                handler: unlockHandler,
+                disabled: !locked
+            });
+            o.push({
+                cls: lockCls,
+                text: lockText,
+                handler: lockHandler,
+                disabled: locked
+            });
+            return o;
+        };
+    },
+
+    
+    
+    lock: function(activeHd, toIdx) {
+        var me         = this,
+            normalGrid = me.normalGrid,
+            lockedGrid = me.lockedGrid,
+            normalHCt  = normalGrid.headerCt,
+            lockedHCt  = lockedGrid.headerCt;
+
+        activeHd = activeHd || normalHCt.getMenu().activeHeader;
+
+        
+        
+        if (activeHd.flex) {
+            activeHd.width = activeHd.getWidth();
+            delete activeHd.flex;
+        }
+
+        Ext.suspendLayouts();
+        activeHd.ownerCt.remove(activeHd, false);
+        activeHd.locked = true;
+        if (Ext.isDefined(toIdx)) {
+            lockedHCt.insert(toIdx, activeHd);
+        } else {
+            lockedHCt.add(activeHd);
+        }
+        me.syncLockedSection();
+        Ext.resumeLayouts(true);
+        me.updateSpacer();
+
+        me.fireEvent('lockcolumn', me, activeHd);
+    },
+
+    syncLockedSection: function() {
+        var me = this;
+        me.syncLockedWidth();
+        me.lockedGrid.getView().refresh();
+        me.normalGrid.getView().refresh();
+    },
+
+    
+    
+    syncLockedWidth: function() {
+        var me = this,
+            locked = me.lockedGrid,
+            width = locked.headerCt.getFullWidth(true);
+            
+        Ext.suspendLayouts();
+        if (width > 0) {
+            locked.setWidth(width);
+            locked.show();
+        } else {
+            locked.hide();
+        }
+        Ext.resumeLayouts(true);
+        
+        return width > 0;
+    },
+
+    onLockedHeaderResize: function() {
+        this.syncLockedWidth();
+    },
+
+    onLockedHeaderHide: function() {
+        this.syncLockedWidth();
+    },
+
+    onLockedHeaderShow: function() {
+        this.syncLockedWidth();
+    },
+
+    onLockedHeaderSortChange: function(headerCt, header, sortState) {
+        if (sortState) {
+            
+            
+            this.normalGrid.headerCt.clearOtherSortStates(null, true);
+        }
+    },
+
+    onNormalHeaderSortChange: function(headerCt, header, sortState) {
+        if (sortState) {
+            
+            
+            this.lockedGrid.headerCt.clearOtherSortStates(null, true);
+        }
+    },
+
+    
+    
+    unlock: function(activeHd, toIdx) {
+        var me         = this,
+            normalGrid = me.normalGrid,
+            lockedGrid = me.lockedGrid,
+            normalHCt  = normalGrid.headerCt,
+            lockedHCt  = lockedGrid.headerCt,
+            refreshLocked = false;
+
+        if (!Ext.isDefined(toIdx)) {
+            toIdx = 0;
+        }
+        activeHd = activeHd || lockedHCt.getMenu().activeHeader;
+
+        Ext.suspendLayouts();
+        activeHd.ownerCt.remove(activeHd, false);
+        if (me.syncLockedWidth()) {
+            refreshLocked = true;
+        }
+        activeHd.locked = false;
+
+        
+        normalHCt.insert(toIdx, activeHd);
+        me.normalGrid.getView().refresh();
+
+        if (refreshLocked) {
+            me.lockedGrid.getView().refresh();
+        }
+        Ext.resumeLayouts(true);
+
+        me.fireEvent('unlockcolumn', me, activeHd);
+    },
+
+    applyColumnsState: function (columns) {
+        var me             = this,
+            lockedGrid     = me.lockedGrid,
+            lockedHeaderCt = lockedGrid.headerCt,
+            normalHeaderCt = me.normalGrid.headerCt,
+            lockedCols     = Ext.Array.toMap(lockedHeaderCt.items, 'headerId'),
+            normalCols     = Ext.Array.toMap(normalHeaderCt.items, 'headerId'),
+            locked         = [],
+            normal         = [],
+            lockedWidth    = 1,
+            length         = columns.length,
+            i, existing,
+            lockedDefault,
+            col;
+
+        for (i = 0; i < length; i++) {
+            col = columns[i];
+
+            lockedDefault = lockedCols[col.id];
+            existing = lockedDefault || normalCols[col.id];
+
+            if (existing) {
+                if (existing.applyColumnState) {
+                    existing.applyColumnState(col);
+                }
+                if (existing.locked === undefined) {
+                    existing.locked = !!lockedDefault;
+                }
+                if (existing.locked) {
+                    locked.push(existing);
+                    if (!existing.hidden && typeof existing.width == 'number') {
+                        lockedWidth += existing.width;
+                    }
+                } else {
+                    normal.push(existing);
+                }
+            }
+        }
+
+        
+        if (locked.length + normal.length == lockedHeaderCt.items.getCount() + normalHeaderCt.items.getCount()) {
+            lockedHeaderCt.removeAll(false);
+            normalHeaderCt.removeAll(false);
+
+            lockedHeaderCt.add(locked);
+            normalHeaderCt.add(normal);
+
+            lockedGrid.setWidth(lockedWidth);
+        }
+    },
+
+    getColumnsState: function () {
+        var me = this,
+            locked = me.lockedGrid.headerCt.getColumnsState(),
+            normal = me.normalGrid.headerCt.getColumnsState();
+
+        return locked.concat(normal);
+    },
+
+    
+    reconfigureLockable: function(store, columns) {
+        var me = this,
+            lockedGrid = me.lockedGrid,
+            normalGrid = me.normalGrid;
+
+        if (columns) {
+            Ext.suspendLayouts();
+            lockedGrid.headerCt.removeAll();
+            normalGrid.headerCt.removeAll();
+
+            columns = me.processColumns(columns);
+            lockedGrid.setWidth(columns.lockedWidth);
+            lockedGrid.headerCt.add(columns.locked.items);
+            normalGrid.headerCt.add(columns.normal.items);
+            Ext.resumeLayouts(true);
+        }
+
+        if (store) {
+            store = Ext.data.StoreManager.lookup(store);
+            me.store = store;
+            lockedGrid.bindStore(store);
+            normalGrid.bindStore(store);
+        } else {
+            lockedGrid.getView().refresh();
+            normalGrid.getView().refresh();
+        }
+    },
+
+    
+    cloneFeatures: function() {
+        var me = this,
+            features = me.features,
+            feature,
+            i = 0, len;
+        
+        if (features) {
+            len = features.length;
+            for (; i < len; i++) {
+                feature = features[i];
+                if (feature.isFeature) {
+                    features[i] = feature.clone();
+                }
+            }
+        }
+    },
+
+    
+    clonePlugins: function() {
+        var me = this,
+            plugins = me.plugins,
+            plugin,
+            i = 0, len;
+        
+        if (plugins) {
+            len = plugins.length;
+            for (; i < len; i++) {
+                plugin = plugins[i];
+                if (typeof plugin.init === 'function') {
+                    plugins[i] = plugin.clone();
+                }
+            }
+        }
+    }
+}, function() {
+    this.borrow(Ext.view.Table, ['constructFeatures']);
+    this.borrow(Ext.AbstractComponent, ['constructPlugins', 'constructPlugin']);
+});
+
+
+Ext.define('Ext.grid.PagingScroller', {
+
+    
+    percentageFromEdge: 0.35,
+
+    
+    numFromEdge: 2,
+
+    
+    trailingBufferZone: 5,
+
+    
+    leadingBufferZone: 15,
+
+    
+    scrollToLoadBuffer: 200,
+
+    
+    viewSize: 0,
+    
+    rowHeight: 21,
+    
+    tableStart: 0,
+    tableEnd: 0,
+
+    constructor: function(config) {
+        var me = this;
+        me.variableRowHeight = config.variableRowHeight;
+        me.bindView(config.view);
+        Ext.apply(me, config);
+        me.callParent(arguments);
+    },
+
+    bindView: function(view) {
+        var me = this,
+            viewListeners = {
+                scroll: {
+                    fn: me.onViewScroll,
+                    element: 'el',
+                    scope: me
+                },
+                render: me.onViewRender,
+                resize: me.onViewResize,
+                boxready: {
+                    fn: me.onViewResize,
+                    scope: me,
+                    single: true
+                },
+
+                
+                
+                
+                beforerefresh: me.beforeViewRefresh,
+
+                refresh: me.onViewRefresh,
+                scope: me
+            },
+            storeListeners = {
+                guaranteedrange: me.onGuaranteedRange,
+                scope: me
+            },
+            gridListeners = {
+                reconfigure: me.onGridReconfigure,
+                scope: me
+            }, partner;
+
+        
+        if (me.view) {
+            if (me.view.el) {
+                me.view.el.un('scroll', me.onViewScroll, me); 
+            }
+            
+            partner = view.lockingPartner;
+            if (partner) {
+                partner.un('refresh', me.onLockRefresh, me);
+            }
+            
+            me.view.un(viewListeners);
+            me.store.un(storeListeners);
+            if (me.grid) {
+                me.grid.un(gridListeners);
+            }
+            delete me.view.refreshSize; 
+        }
+
+        me.view = view;
+        me.grid = me.view.up('tablepanel');
+        me.store = view.store;
+        if (view.rendered) {
+            me.viewSize = me.store.viewSize = Math.ceil(view.getHeight() / me.rowHeight) + me.trailingBufferZone + (me.numFromEdge * 2) + me.leadingBufferZone;
+        }
+        
+        partner = view.lockingPartner;
+        if (partner) {
+            partner.on('refresh', me.onLockRefresh, me);
+        }
+
+        me.view.mon(me.store.pageMap, {
+            scope: me,
+            clear: me.onCacheClear
+        });
+
+        
+        
+        
+        me.view.refreshSize = Ext.Function.createInterceptor(me.view.refreshSize, me.beforeViewrefreshSize, me);
+
+        
+        me.position = 0;
+
+        
+        if (me.grid) {
+            me.grid.on(gridListeners);
+        } else {
+            me.view.on({
+                added: function() {
+                    me.grid = me.view.up('tablepanel');
+                    me.grid.on(gridListeners);
+                },
+                single: true
+            });
+        }
+
+        me.view.on(me.viewListeners = viewListeners);
+        me.store.on(storeListeners);
+    },
+
+    onCacheClear: function() {
+        var me = this;
+
+        
+        if (me.view.rendered && !me.store.isDestroyed) {
+            
+            
+            me.ignoreNextScrollEvent = me.view.el.dom.scrollTop !== 0;
+
+            me.view.el.dom.scrollTop = 0;
+            delete me.lastScrollDirection;
+            delete me.scrollOffset;
+            delete me.scrollProportion;
+        }
+    },
+
+    onGridReconfigure: function (grid) {
+        this.bindView(grid.view);
+    },
+
+    
+    onViewRender: function() {
+        var me = this,
+            view = me.view,
+            el = me.view.el,
+            stretcher;
+
+        me.stretcher = me.createStretcher(view);
+        
+        view = view.lockingPartner;
+        if (view) {
+            stretcher = me.stretcher;
+            me.stretcher = new Ext.CompositeElement(stretcher);
+            me.stretcher.add(me.createStretcher(view));
+        }
+    },
+    
+    createStretcher: function(view) {
+        var el = view.el;
+        el.setStyle('position', 'relative');
+        
+        return el.createChild({
+            style:{
+                position: 'absolute',
+                width: '1px',
+                height: 0,
+                top: 0,
+                left: 0
+            }
+        }, el.dom.firstChild);
+    },
+    
+    onViewResize: function(view, width, height) {
+        var me = this,
+            newViewSize;
+
+        newViewSize = Math.ceil(height / me.rowHeight) + me.trailingBufferZone + (me.numFromEdge * 2) + me.leadingBufferZone;
+        if (newViewSize > me.viewSize) {
+            me.viewSize = me.store.viewSize = newViewSize;
+            me.handleViewScroll(me.lastScrollDirection || 1);
+        }
+    },
+
+    
+    beforeViewRefresh: function() {
+        var me = this,
+            view = me.view,
+            rows,
+            direction;
+
+        
+        me.focusOnRefresh = Ext.Element.getActiveElement === view.el.dom;
+
+        
+        if (me.variableRowHeight) {
+            direction = me.lastScrollDirection;
+            me.commonRecordIndex = undefined;
+            
+            
+            
+            
+            if (direction && (me.previousStart !== undefined) && (me.scrollProportion === undefined) && (rows = view.getNodes()).length) {
+
+                
+                if (direction === 1) {
+
+                    
+                    if (me.tableStart <= me.previousEnd) {
+                        me.commonRecordIndex = rows.length - 1;
+
+                    }
+                }
+                
+                else if (direction === -1) {
+
+                    
+                    if (me.tableEnd >= me.previousStart) {
+                        me.commonRecordIndex = 0;
+                    }
+                }
+                
+                me.scrollOffset = -view.el.getOffsetsTo(rows[me.commonRecordIndex])[1];
+
+                
+                me.commonRecordIndex -= (me.tableStart - me.previousStart);
+            } else {
+                me.scrollOffset = undefined;
+            }
+        }
+    },
+
+    onLockRefresh: function(view) {
+        view.table.dom.style.position = 'absolute';
+    },
+
+    
+    
+    onViewRefresh: function() {
+        var me = this,
+            store = me.store,
+            newScrollHeight,
+            view = me.view,
+            viewEl = view.el,
+            viewDom = viewEl.dom,
+            rows,
+            newScrollOffset,
+            scrollDelta,
+            table = view.table.dom,
+            tableTop,
+            scrollTop;
+
+        
+        if (me.focusOnRefresh) {
+            viewEl.focus();
+            me.focusOnRefresh = false;
+        }
+
+        
+        me.disabled = true;
+
+        
+        
+        
+        
+        
+        if (store.getCount() === store.getTotalCount() || (store.isFiltered() && !store.remoteFilter)) {
+            me.stretcher.setHeight(0);
+            me.position = viewDom.scrollTop = 0;
+
+            
+            
+            me.setTablePosition('absolute');
+
+            
+            return;
+        }
+
+        me.stretcher.setHeight(newScrollHeight = me.getScrollHeight());
+
+        scrollTop = viewDom.scrollTop;
+
+        
+        me.isScrollRefresh = (scrollTop > 0);
+
+        
+        
+        if (me.scrollProportion !== undefined) {
+            me.setTablePosition('absolute');
+            me.setTableTop((me.scrollProportion ? (newScrollHeight * me.scrollProportion) - (table.offsetHeight * me.scrollProportion) : 0) + 'px');
+        } else {
+            me.setTablePosition('absolute');
+            me.setTableTop((tableTop = (me.tableStart||0) * me.rowHeight) + 'px');
+
+            
+            if (me.scrollOffset) {
+                rows = view.getNodes();
+                newScrollOffset = -viewEl.getOffsetsTo(rows[me.commonRecordIndex])[1];
+                scrollDelta = newScrollOffset - me.scrollOffset;
+                me.position = (viewDom.scrollTop += scrollDelta);
+            }
+
+            
+            
+            
+            
+            
+            
+            else if ((tableTop > scrollTop) || ((tableTop + table.offsetHeight) < scrollTop + viewDom.clientHeight)) {
+                me.lastScrollDirection = -1;
+                me.position = viewDom.scrollTop = tableTop;
+            }
+        }
+
+        
+        me.disabled = false;
+    },
+    
+    setTablePosition: function(position) {
+        this.setViewTableStyle(this.view, 'position', position);
+    },
+    
+    setTableTop: function(top){
+        this.setViewTableStyle(this.view, 'top', top);
+    },
+    
+    setViewTableStyle: function(view, prop, value) {
+        view.el.child('table', true).style[prop] = value;
+        view = view.lockingPartner;
+        
+        if (view) {
+            view.el.child('table', true).style[prop] = value;
+        }
+    },
+
+    beforeViewrefreshSize: function() {
+        
+        if (this.isScrollRefresh) {
+            
+            this.view.table.attach(this.view.el.child('table', true));
+            return (this.isScrollRefresh = false);
+        }
+    },
+
+    onGuaranteedRange: function(range, start, end) {
+        var me = this,
+            ds = me.store;
+
+        
+        if (range.length && me.visibleStart < range[0].index) {
+            return;
+        }
+
+        
+        
+        me.previousStart = me.tableStart;
+        me.previousEnd = me.tableEnd;
+
+        me.tableStart = start;
+        me.tableEnd = end;
+        ds.loadRecords(range, {
+            start: start
+        });
+    },
+
+    onViewScroll: function(e, t) {
+        var me = this,
+            view = me.view,
+            lastPosition = me.position;
+
+        me.position = view.el.dom.scrollTop;
+
+        
+        
+        if (me.ignoreNextScrollEvent) {
+            me.ignoreNextScrollEvent = false;
+            return;
+        }
+
+        
+        
+        if (!me.disabled) {
+            me.lastScrollDirection = me.position > lastPosition ? 1 : -1;
+            
+            if (lastPosition !== me.position) {
+                me.handleViewScroll(me.lastScrollDirection);
+            }
+        }
+    },
+
+    handleViewScroll: function(direction) {
+        var me                = this,
+            store             = me.store,
+            view              = me.view,
+            viewSize          = me.viewSize,
+            totalCount        = store.getTotalCount(),
+            highestStartPoint = totalCount - viewSize,
+            visibleStart      = me.getFirstVisibleRowIndex(),
+            visibleEnd        = me.getLastVisibleRowIndex(),
+            el                = view.el.dom,
+            requestStart,
+            requestEnd;
+
+        
+        if (totalCount >= viewSize) {
+
+            
+            
+            
+            
+            me.scrollProportion = undefined;
+
+            
+            if (direction == -1) {
+
+                
+                if (me.tableStart) {
+                    if (visibleStart !== undefined) {
+                        if (visibleStart < (me.tableStart + me.numFromEdge)) {
+                            requestStart = Math.max(0, visibleEnd + me.trailingBufferZone - viewSize);
+                        }
+                    }
+
+                    
+                    
+                    else {
+                        
+                        me.scrollProportion = el.scrollTop / (el.scrollHeight - el.clientHeight);
+                        requestStart = Math.max(0, totalCount * me.scrollProportion - (viewSize / 2) - me.numFromEdge - ((me.leadingBufferZone + me.trailingBufferZone) / 2));
+                    }
+                }
+            }
+            
+            else {
+                if (visibleStart !== undefined) {
+                    if (visibleEnd > (me.tableEnd - me.numFromEdge)) {
+                        requestStart = Math.max(0, visibleStart - me.trailingBufferZone);
+                    }
+                }
+
+                
+                
+                else {
+                    
+                    me.scrollProportion = el.scrollTop / (el.scrollHeight - el.clientHeight);
+                    requestStart = totalCount * me.scrollProportion - (viewSize / 2) - me.numFromEdge - ((me.leadingBufferZone + me.trailingBufferZone) / 2);
+                }
+            }
+
+            
+            if (requestStart !== undefined) {
+                
+                if (requestStart > highestStartPoint) {
+                    requestStart = highestStartPoint & ~1;
+                    requestEnd = totalCount - 1;
+                }
+                
+                else {
+                    requestStart = requestStart & ~1;
+                    requestEnd = requestStart + viewSize - 1;
+                }
+
+                
+                if (store.rangeCached(requestStart, requestEnd)) {
+                    me.cancelLoad();
+                    store.guaranteeRange(requestStart, requestEnd);
+                }
+
+                
+                
+                else {
+                    me.attemptLoad(requestStart, requestEnd);
+                }
+            }
+        }
+    },
+
+    getFirstVisibleRowIndex: function() {
+        var me = this,
+            view = me.view,
+            scrollTop = view.el.dom.scrollTop,
+            rows,
+            count,
+            i,
+            rowBottom;
+
+        if (me.variableRowHeight) {
+            rows = view.getNodes();
+            count = rows.length;
+            if (!count) {
+                return;
+            }
+            rowBottom = Ext.fly(rows[0]).getOffsetsTo(view.el)[1];
+            for (i = 0; i < count; i++) {
+                rowBottom += rows[i].offsetHeight;
+
+                
+                if (rowBottom > view.el.dom.clientHeight) {
+                    return;
+                }
+
+                
+                
+                if (rowBottom > 0) {
+                    return view.getRecord(rows[i]).index;
+                }
+            }
+        } else {
+            return Math.floor(scrollTop / me.rowHeight);
+        }
+    },
+
+    getLastVisibleRowIndex: function() {
+        var me = this,
+            store = me.store,
+            view = me.view,
+            clientHeight = view.el.dom.clientHeight,
+            rows,
+            count,
+            i,
+            rowTop;
+
+        if (me.variableRowHeight) {
+            rows = view.getNodes();
+            if (!rows.length) {
+                return;
+            }
+            count = store.getCount() - 1;
+            rowTop = Ext.fly(rows[count]).getOffsetsTo(view.el)[1] + rows[count].offsetHeight;
+            for (i = count; i >= 0; i--) {
+                rowTop -= rows[i].offsetHeight;
+
+                
+                if (rowTop < 0) {
+                    return;
+                }
+
+                
+                
+                if (rowTop < clientHeight) {
+                    return view.getRecord(rows[i]).index;
+                }
+            }
+        } else {
+            return me.getFirstVisibleRowIndex() + Math.ceil(clientHeight / me.rowHeight) + 1;
+        }
+    },
+
+    getScrollHeight: function() {
+        var me = this,
+            view   = me.view,
+            table,
+            firstRow,
+            store  = me.store,
+            deltaHeight = 0,
+            doCalcHeight = !me.hasOwnProperty('rowHeight');
+
+        if (me.variableRowHeight) {
+            table = me.view.table.dom;
+            if (doCalcHeight) {
+                me.initialTableHeight = table.offsetHeight;
+                me.rowHeight = me.initialTableHeight / me.store.getCount();
+            } else {
+                deltaHeight = table.offsetHeight - me.initialTableHeight;
+
+                
+                if (store.getCount() > me.viewSize) {
+                    deltaHeight -= me.rowHeight;
+                }
+            }
+        } else if (doCalcHeight) {
+            firstRow = view.el.down(view.getItemSelector());
+            if (firstRow) {
+                me.rowHeight = firstRow.getHeight(false, true);
+            }
+        }
+
+        return Math.floor(store.getTotalCount() * me.rowHeight) + deltaHeight;
+    },
+
+    attemptLoad: function(start, end) {
+        var me = this;
+        if (me.scrollToLoadBuffer) {
+            if (!me.loadTask) {
+                me.loadTask = new Ext.util.DelayedTask(me.doAttemptLoad, me, []);
+            }
+            me.loadTask.delay(me.scrollToLoadBuffer, me.doAttemptLoad, me, [start, end]);
+        } else {
+            me.store.guaranteeRange(start, end);
+        }
+    },
+
+    cancelLoad: function() {
+        if (this.loadTask) {
+            this.loadTask.cancel();
+        }
+    },
+
+    doAttemptLoad:  function(start, end) {
+        this.store.guaranteeRange(start, end);
+    },
+
+    destroy: function() {
+        var me = this,
+            scrollListener = me.viewListeners.scroll;
+
+        me.store.un({
+            guaranteedrange: me.onGuaranteedRange,
+            scope: me
+        });
+        me.view.un(me.viewListeners);
+        if (me.view.rendered) {
+            me.stretcher.remove();
+            me.view.el.un('scroll', scrollListener.fn, scrollListener.scope);
+        }
+    }
+});
+
+
+Ext.define('Ext.layout.container.Fit', {
+
+    
+    extend: 'Ext.layout.container.Container',
+    alternateClassName: 'Ext.layout.FitLayout',
+
+    alias: 'layout.fit',
+
+    
+
+    itemCls: Ext.baseCSSPrefix + 'fit-item',
+    targetCls: Ext.baseCSSPrefix + 'layout-fit',
+    type: 'fit',
+   
+    
+    defaultMargins: {
+        top: 0,
+        right: 0,
+        bottom: 0,
+        left: 0
+    },
+
+    manageMargins: true,
+
+    sizePolicies: {
+        0: { setsWidth: 0, setsHeight: 0 },
+        1: { setsWidth: 1, setsHeight: 0 },
+        2: { setsWidth: 0, setsHeight: 1 },
+        3: { setsWidth: 1, setsHeight: 1 }
+    },
+
+    getItemSizePolicy: function (item, ownerSizeModel) {
+        
+        var sizeModel = ownerSizeModel || this.owner.getSizeModel(),
+            mode = (sizeModel.width.shrinkWrap ? 0 : 1) |
+                   (sizeModel.height.shrinkWrap ? 0 : 2);
+
+       return this.sizePolicies[mode];
+    },
+
+    beginLayoutCycle: function (ownerContext, firstCycle) {
+        var me = this,
+            
+            resetHeight = me.lastHeightModel && me.lastHeightModel.calculated,
+            resetWidth = me.lastWidthModel && me.lastWidthModel.calculated,
+            resetSizes = resetWidth || resetHeight,
+            maxChildMinHeight = 0, maxChildMinWidth = 0,
+            c, childItems, i, item, length, margins, minHeight, minWidth, style, undef;
+
+        me.callParent(arguments);
+
+        
+        
+        
+        
+        if (resetSizes && ownerContext.targetContext.el.dom.tagName.toUpperCase() != 'TD') {
+            resetSizes = resetWidth = resetHeight = false;
+        }
+
+        childItems = ownerContext.childItems;
+        length = childItems.length;
+
+        for (i = 0; i < length; ++i) {
+            item = childItems[i];
+
+            
+            
+            
+            if (firstCycle) {
+                c = item.target;
+                minHeight = c.minHeight;
+                minWidth = c.minWidth;
+
+                if (minWidth || minHeight) {
+                    margins = item.marginInfo || item.getMarginInfo();
+                    
+                    
+                    minHeight += margins.height;
+                    minWidth += margins.height;
+
+                    
+                    
+                    if (maxChildMinHeight < minHeight) {
+                        maxChildMinHeight = minHeight;
+                    }
+                    if (maxChildMinWidth < minWidth) {
+                        maxChildMinWidth = minWidth;
+                    }
+                }
+            }
+
+            if (resetSizes) {
+                style = item.el.dom.style;
+
+                if (resetHeight) {
+                    style.height = '';
+                }
+                if (resetWidth) {
+                    style.width = '';
+                }
+            }
+        }
+
+        if (firstCycle) {
+            ownerContext.maxChildMinHeight = maxChildMinHeight;
+            ownerContext.maxChildMinWidth = maxChildMinWidth;
+        }
+
+        
+        
+        
+        c = ownerContext.target;
+        ownerContext.overflowX = (!ownerContext.widthModel.shrinkWrap && 
+                                   ownerContext.maxChildMinWidth &&
+                                   (c.autoScroll || c.overflowX)) || undef;
+
+        ownerContext.overflowY = (!ownerContext.heightModel.shrinkWrap &&
+                                   ownerContext.maxChildMinHeight &&
+                                   (c.autoScroll || c.overflowY)) || undef;
+    },
+
+    calculate : function (ownerContext) {
+        var me = this,
+            childItems = ownerContext.childItems,
+            length = childItems.length,
+            containerSize = me.getContainerSize(ownerContext),
+            info = {
+                length: length,
+                ownerContext: ownerContext,
+                targetSize: containerSize
+            },
+            shrinkWrapWidth = ownerContext.widthModel.shrinkWrap,
+            shrinkWrapHeight = ownerContext.heightModel.shrinkWrap,
+            overflowX = ownerContext.overflowX,
+            overflowY = ownerContext.overflowY,
+            scrollbars, scrollbarSize, padding, i, contentWidth, contentHeight;
+
+        if (overflowX || overflowY) {
+            
+            
+            
+            scrollbars = me.getScrollbarsNeeded(
+                    overflowX && containerSize.width, overflowY && containerSize.height,
+                    ownerContext.maxChildMinWidth, ownerContext.maxChildMinHeight);
+
+            if (scrollbars) {
+                scrollbarSize = Ext.getScrollbarSize();
+                if (scrollbars & 1) { 
+                    containerSize.height -= scrollbarSize.height;
+                }
+                if (scrollbars & 2) { 
+                    containerSize.width -= scrollbarSize.width;
+                }
+            }
+        }
+
+        
+        for (i = 0; i < length; ++i) {
+            info.index = i;
+            me.fitItem(childItems[i], info);
+        }
+        
+        if (shrinkWrapHeight || shrinkWrapWidth) {
+            padding = ownerContext.targetContext.getPaddingInfo();
+            
+            if (shrinkWrapWidth) {
+                if (overflowY && !containerSize.gotHeight) {
+                    
+                    
+                    
+                    me.done = false;
+                } else {
+                    contentWidth = info.contentWidth + padding.width;
+                    
+                    
+                    
+                    if (scrollbars & 2) { 
+                        contentWidth += scrollbarSize.width;
+                    }
+                    if (!ownerContext.setContentWidth(contentWidth)) {
+                        me.done = false;
+                    }
+                }
+            }
+
+            if (shrinkWrapHeight) {
+                if (overflowX && !containerSize.gotWidth) {
+                    
+                    
+                    
+                    me.done = false;
+                } else {
+                    contentHeight = info.contentHeight + padding.height;
+                    
+                    
+                    
+                    if (scrollbars & 1) { 
+                        contentHeight += scrollbarSize.height;
+                    }
+                    if (!ownerContext.setContentHeight(contentHeight)) {
+                        me.done = false;
+                    }
+                }
+            }
+        }
+    },
+
+    fitItem: function (itemContext, info) {
+        var me = this;
+
+        if (itemContext.invalid) {
+            me.done = false;
+            return;
+        }
+
+        info.margins = itemContext.getMarginInfo();
+        info.needed = info.got = 0;
+
+        me.fitItemWidth(itemContext, info);
+        me.fitItemHeight(itemContext, info);
+
+        
+        if (info.got != info.needed) {
+            me.done = false;
+        }
+    },
+
+    fitItemWidth: function (itemContext, info) {
+        var contentWidth, width;
+        
+        if (info.ownerContext.widthModel.shrinkWrap) {
+            
+            width = itemContext.getProp('width') + info.margins.width;
+            
+
+            contentWidth = info.contentWidth;
+            if (contentWidth === undefined) {
+                info.contentWidth = width;
+            } else {
+                info.contentWidth = Math.max(contentWidth, width);
+            }
+        } else if (itemContext.widthModel.calculated) {
+            ++info.needed;
+            if (info.targetSize.gotWidth) {
+                ++info.got;
+                this.setItemWidth(itemContext, info);
+            }
+        }
+
+        this.positionItemX(itemContext, info);
+    },
+
+    fitItemHeight: function (itemContext, info) {
+        var contentHeight, height;
+        if (info.ownerContext.heightModel.shrinkWrap) {
+            
+            height = itemContext.getProp('height') + info.margins.height;
+            
+
+            contentHeight = info.contentHeight;
+            if (contentHeight === undefined) {
+                info.contentHeight = height;
+            } else {
+                info.contentHeight = Math.max(contentHeight, height);
+            }
+        } else if (itemContext.heightModel.calculated) {
+            ++info.needed;
+            if (info.targetSize.gotHeight) {
+                ++info.got;
+                this.setItemHeight(itemContext, info);
+            }
+        }
+
+        this.positionItemY(itemContext, info);
+    },
+
+    positionItemX: function (itemContext, info) {
+        var margins = info.margins;
+
+        
+        
+        if (info.index || margins.left) {
+            itemContext.setProp('x', margins.left);
+        }
+
+        if (margins.width) {
+            
+            itemContext.setProp('margin-right', margins.width);
+        }
+    },
+
+    positionItemY: function (itemContext, info) {
+        var margins = info.margins;
+
+        if (info.index || margins.top) {
+            itemContext.setProp('y', margins.top);
+        }
+
+        if (margins.height) {
+            
+            itemContext.setProp('margin-bottom', margins.height);
+        }
+    },
+
+    setItemHeight: function (itemContext, info) {
+        itemContext.setHeight(info.targetSize.height - info.margins.height);
+    },
+
+    setItemWidth: function (itemContext, info) {
+        itemContext.setWidth(info.targetSize.width - info.margins.width);
+    }
+});
+
+
+Ext.define('Ext.panel.Table', {
+    extend: 'Ext.panel.Panel',
+
+    alias: 'widget.tablepanel',
+
+    uses: [
+        'Ext.selection.RowModel',
+        'Ext.selection.CellModel',
+        'Ext.selection.CheckboxModel',
+        'Ext.grid.PagingScroller',
+        'Ext.grid.header.Container',
+        'Ext.grid.Lockable'
+    ],
+
+    extraBaseCls: Ext.baseCSSPrefix + 'grid',
+    extraBodyCls: Ext.baseCSSPrefix + 'grid-body',
+
+    layout: 'fit',
+    
+    hasView: false,
+
+    
+    
+    viewType: null,
+
+    
+
+    
+
+    
+    selType: 'rowmodel',
+
+    
+
+    
+
+    
+
+    
+
+    
+    scroll: true,
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    deferRowRender: true,
+     
+    
+    sortableColumns: true,
+
+    
+    enableLocking: false,
+
+    
+    
+    scrollerOwner: true,
+
+    
+    enableColumnMove: true,
+    
+    
+    sealedColumns: false,
+
+    
+    enableColumnResize: true,
+
+    
+    enableColumnHide: true,
+
+    
+
+    
+    rowLines: true,
+
+    
+
+    
+    
+    
+
+    
+
+    initComponent: function() {
+
+        var me          = this,
+            scroll      = me.scroll,
+            vertical    = false,
+            horizontal  = false,
+            headerCtCfg = me.columns || me.colModel,
+            view,
+            border = me.border,
+            i, len;
+
+        if (me.columnLines) {
+            me.addCls(Ext.baseCSSPrefix + 'grid-with-col-lines');
+        }
+
+        if (me.rowLines) {
+            me.addCls(Ext.baseCSSPrefix + 'grid-with-row-lines');
+        }
+
+        
+        me.store = Ext.data.StoreManager.lookup(me.store || 'ext-empty-store');
+
+
+        
+        
+        if (headerCtCfg instanceof Ext.grid.header.Container) {
+            me.headerCt = headerCtCfg;
+            me.headerCt.border = border;
+            me.columns = me.headerCt.items.items;
+        } else {
+            if (Ext.isArray(headerCtCfg)) {
+                headerCtCfg = {
+                    items: headerCtCfg,
+                    border: border
+                };
+            }
+            Ext.apply(headerCtCfg, {
+                forceFit: me.forceFit,
+                sortable: me.sortableColumns,
+                enableColumnMove: me.enableColumnMove,
+                enableColumnResize: me.enableColumnResize,
+                enableColumnHide: me.enableColumnHide,
+                border:  border,
+                sealed: me.sealedColumns
+            });
+            me.columns = headerCtCfg.items;
+
+             
+             
+             if (me.enableLocking || Ext.ComponentQuery.query('{locked !== undefined}{processed != true}', me.columns).length) {
+                 me.self.mixin('lockable', Ext.grid.Lockable);
+                 me.injectLockable();
+             }
+        }
+
+        me.scrollTask = new Ext.util.DelayedTask(me.syncHorizontalScroll, me);
+
+        me.addEvents(
+            
+            'reconfigure',
+            
+            'viewready'
+        );
+
+        me.bodyCls = me.bodyCls || '';
+        me.bodyCls += (' ' + me.extraBodyCls);
+        
+        me.cls = me.cls || '';
+        me.cls += (' ' + me.extraBaseCls);
+
+        
+        delete me.autoScroll;
+
+        
+        
+        if (!me.hasView) {
+
+            
+            
+            if (!me.headerCt) {
+                me.headerCt = new Ext.grid.header.Container(headerCtCfg);
+            }
+
+            
+            me.columns = me.headerCt.items.items;
+
+            
+            if (me.store.buffered && !me.store.remoteSort) {
+                for (i = 0, len = me.columns.length; i < len; i++) {
+                    me.columns[i].sortable = false;
+                }
+            }
+
+            if (me.hideHeaders) {
+                me.headerCt.height = 0;
+                me.headerCt.addCls(Ext.baseCSSPrefix + 'grid-header-ct-hidden');
+                me.addCls(Ext.baseCSSPrefix + 'grid-header-hidden');
+                
+                
+                if (Ext.isIEQuirks) {
+                    me.headerCt.style = {
+                        display: 'none'
+                    };
+                }
+            }
+
+            
+            if (scroll === true || scroll === 'both') {
+                vertical = horizontal = true;
+            } else if (scroll === 'horizontal') {
+                horizontal = true;
+            } else if (scroll === 'vertical') {
+                vertical = true;
+            }
+
+            me.relayHeaderCtEvents(me.headerCt);
+            me.features = me.features || [];
+            if (!Ext.isArray(me.features)) {
+                me.features = [me.features];
+            }
+            me.dockedItems = [].concat(me.dockedItems || []);
+            me.dockedItems.unshift(me.headerCt);
+            me.viewConfig = me.viewConfig || {};
+
+            
+            if (me.store && me.store.buffered) {
+                me.viewConfig.preserveScrollOnRefresh = true;
+            } else if (me.invalidateScrollerOnRefresh !== undefined) {
+                me.viewConfig.preserveScrollOnRefresh = !me.invalidateScrollerOnRefresh;
+            }
+
+            
+            
+            view = me.getView();
+
+            me.items = [view];
+            me.hasView = true;
+
+            if (vertical) {
+                
+                
+                if (me.store.buffered) {
+                    me.verticalScroller = new Ext.grid.PagingScroller(Ext.apply({
+                        panel: me,
+                        store: me.store,
+                        view: me.view
+                    }, me.verticalScroller));
+                }
+            }
+
+            if (horizontal) {
+                
+                
+                if (!me.hideHeaders) {
+                    view.on({
+                        scroll: {
+                            fn: me.onHorizontalScroll,
+                            element: 'el',
+                            scope: me
+                        }
+                    });
+                }
+            }
+
+            me.mon(view.store, {
+                load: me.onStoreLoad,
+                scope: me
+            });
+            me.mon(view, {
+                viewready: me.onViewReady,
+                refresh: me.onRestoreHorzScroll,
+                scope: me
+            });
+        }
+
+        
+        this.relayEvents(me.view, [
+            
+            'beforeitemmousedown',
+            
+            'beforeitemmouseup',
+            
+            'beforeitemmouseenter',
+            
+            'beforeitemmouseleave',
+            
+            'beforeitemclick',
+            
+            'beforeitemdblclick',
+            
+            'beforeitemcontextmenu',
+            
+            'itemmousedown',
+            
+            'itemmouseup',
+            
+            'itemmouseenter',
+            
+            'itemmouseleave',
+            
+            'itemclick',
+            
+            'itemdblclick',
+            
+            'itemcontextmenu',
+            
+            'beforecontainermousedown',
+            
+            'beforecontainermouseup',
+            
+            'beforecontainermouseover',
+            
+            'beforecontainermouseout',
+            
+            'beforecontainerclick',
+            
+            'beforecontainerdblclick',
+            
+            'beforecontainercontextmenu',
+            
+            'containermouseup',
+            
+            'containermouseover',
+            
+            'containermouseout',
+            
+            'containerclick',
+            
+            'containerdblclick',
+            
+            'containercontextmenu',
+            
+            'selectionchange',
+            
+            'beforeselect',
+            
+            'select',
+            
+            'beforedeselect',
+            
+            'deselect'
+        ]);
+
+        me.callParent(arguments);
+        me.addStateEvents(['columnresize', 'columnmove', 'columnhide', 'columnshow', 'sortchange']);
+
+        if (me.headerCt) {
+            me.headerCt.on('afterlayout', me.onRestoreHorzScroll, me);
+        }
+    },
+
+    relayHeaderCtEvents: function (headerCt) {
+        this.relayEvents(headerCt, [
+            
+            'columnresize',
+            
+            'columnmove',
+            
+            'columnhide',
+            
+            'columnshow',
+            
+            'sortchange'
+        ]);
+    },
+
+    getState: function(){
+        var me = this,
+            state = me.callParent(),
+            sorter = me.store.sorters.first();
+
+        state = me.addPropertyToState(state, 'columns', (me.headerCt || me).getColumnsState());
+
+        if (sorter) {
+            state = me.addPropertyToState(state, 'sort', {
+                property: sorter.property,
+                direction: sorter.direction,
+                root: sorter.root
+            });
+        }
+        return state;
+    },
+
+    applyState: function(state) {
+        var me = this,
+            sorter = state.sort,
+            store = me.store,
+            columns = state.columns;
+
+        delete state.columns;
+
+        
+        
+        me.callParent(arguments);
+
+        if (columns) {
+            (me.headerCt || me).applyColumnsState(columns);
+        }
+
+        if (sorter) {
+            if (store.remoteSort) {
+                
+                store.sort({
+                    property: sorter.property,
+                    direction: sorter.direction,
+                    root: sorter.root
+                }, null, false);
+            } else {
+                store.sort(sorter.property, sorter.direction);
+            }
+        }
+    },
+
+    
+    getStore: function(){
+        return this.store;
+    },
+
+    
+    getView: function() {
+        var me = this,
+            sm;
+
+        if (!me.view) {
+            sm = me.getSelectionModel();
+            me.view = Ext.widget(Ext.apply({}, me.viewConfig, {
+
+                
+                grid: me,
+                deferInitialRefresh: me.deferRowRender !== false,
+                scroll: me.scroll,
+                xtype: me.viewType,
+                store: me.store,
+                headerCt: me.headerCt,
+                selModel: sm,
+                features: me.features,
+                panel: me,
+                emptyText : me.emptyText ? '<div class="' + Ext.baseCSSPrefix + 'grid-empty">' + me.emptyText + '</div>' : ''
+            }));
+
+            
+            me.view.getComponentLayout().headerCt = me.headerCt;
+
+            me.mon(me.view, {
+                uievent: me.processEvent,
+                scope: me
+            });
+            sm.view = me.view;
+            me.headerCt.view = me.view;
+            me.relayEvents(me.view, [
+                
+                'cellclick',
+                
+                'celldblclick'
+            ]);
+        }
+        return me.view;
+    },
+
+    
+    setAutoScroll: Ext.emptyFn,
+
+    
+    processEvent: function(type, view, cell, recordIndex, cellIndex, e) {
+        var me = this,
+            header;
+
+        if (cellIndex !== -1) {
+            header = me.headerCt.getGridColumns()[cellIndex];
+            return header.processEvent.apply(header, arguments);
+        }
+    },
+
+    
+    determineScrollbars: function () {
+    },
+
+    
+    invalidateScroller: function () {
+    },
+
+    scrollByDeltaY: function(yDelta, animate) {
+        this.getView().scrollBy(0, yDelta, animate);
+    },
+
+    scrollByDeltaX: function(xDelta, animate) {
+        this.getView().scrollBy(xDelta, 0, animate);
+    },
+
+    afterCollapse: function() {
+        var me = this;
+        me.saveScrollPos();
+        me.saveScrollPos();
+        me.callParent(arguments);
+    },
+
+    afterExpand: function() {
+        var me = this;
+        me.callParent(arguments);
+        me.restoreScrollPos();
+        me.restoreScrollPos();
+    },
+
+    saveScrollPos: Ext.emptyFn,
+
+    restoreScrollPos: Ext.emptyFn,
+    
+    onHeaderResize: function(){
+        this.delayScroll();
+    },
+
+    
+    onHeaderMove: function(headerCt, header, colsToMove, fromIdx, toIdx) {
+        var me = this;
+
+        
+        
+        if (me.optimizedColumnMove === false) {
+            me.view.refresh();
+        }
+
+        
+        else {
+            me.view.moveColumn(fromIdx, toIdx, colsToMove);
+        }
+        me.delayScroll();
+    },
+
+    
+    onHeaderHide: function(headerCt, header) {
+        this.delayScroll();
+    },
+
+    onHeaderShow: function(headerCt, header) {
+        this.delayScroll();
+    },
+    
+    delayScroll: function(){
+        var target = this.getScrollTarget().el;
+        if (target) {
+            this.scrollTask.delay(10, null, null, [target.dom.scrollLeft]);
+        }
+    },
+
+    
+    onViewReady: function() {
+         this.fireEvent('viewready', this);   
+    },
+
+    
+    onRestoreHorzScroll: function() {
+        var left = this.scrollLeftPos;
+        if (left) {
+            
+            this.syncHorizontalScroll(left, true);
+        }
+    },
+
+    getScrollerOwner: function() {
+        var rootCmp = this;
+        if (!this.scrollerOwner) {
+            rootCmp = this.up('[scrollerOwner]');
+        }
+        return rootCmp;
+    },
+
+    
+    getLhsMarker: function() {
+        var me = this;
+        return me.lhsMarker || (me.lhsMarker = Ext.DomHelper.append(me.el, {
+            cls: Ext.baseCSSPrefix + 'grid-resize-marker'
+        }, true));
+    },
+
+    
+    getRhsMarker: function() {
+        var me = this;
+
+        return me.rhsMarker || (me.rhsMarker = Ext.DomHelper.append(me.el, {
+            cls: Ext.baseCSSPrefix + 'grid-resize-marker'
+        }, true));
+    },
+
+    
+    getSelectionModel: function(){
+        if (!this.selModel) {
+            this.selModel = {};
+        }
+
+        var mode = 'SINGLE',
+            type;
+        if (this.simpleSelect) {
+            mode = 'SIMPLE';
+        } else if (this.multiSelect) {
+            mode = 'MULTI';
+        }
+
+        Ext.applyIf(this.selModel, {
+            allowDeselect: this.allowDeselect,
+            mode: mode
+        });
+
+        if (!this.selModel.events) {
+            type = this.selModel.selType || this.selType;
+            this.selModel = Ext.create('selection.' + type, this.selModel);
+        }
+
+        if (!this.selModel.hasRelaySetup) {
+            this.relayEvents(this.selModel, [
+                'selectionchange', 'beforeselect', 'beforedeselect', 'select', 'deselect'
+            ]);
+            this.selModel.hasRelaySetup = true;
+        }
+
+        
+        
+        if (this.disableSelection) {
+            this.selModel.locked = true;
+        }
+        return this.selModel;
+    },
+    
+    getScrollTarget: function(){
+        var owner = this.getScrollerOwner(),
+            items = owner.query('tableview');
+            
+        return items[1] || items[0];
+    },
+
+    onHorizontalScroll: function(event, target) {
+        this.syncHorizontalScroll(target.scrollLeft);
+    },
+    
+    syncHorizontalScroll: function(left, setBody) {
+        var me = this,
+            scrollTarget;
+            
+        setBody = setBody === true;
+        
+        
+        if (me.rendered && (setBody || left !== me.scrollLeftPos)) {
+            
+            
+            if (setBody) {   
+                scrollTarget = me.getScrollTarget();
+                scrollTarget.el.dom.scrollLeft = left;
+            }
+            me.headerCt.el.dom.scrollLeft = left;
+            me.scrollLeftPos = left;
+        }
+    },
+
+    
+    onStoreLoad: Ext.emptyFn,
+
+    getEditorParent: function() {
+        return this.body;
+    },
+
+    bindStore: function(store) {
+        var me = this;
+        me.store = store;
+        me.getView().bindStore(store);
+    },
+    
+    beforeDestroy: function(){
+        Ext.destroy(this.verticalScroller);
+        this.callParent();    
+    },
+
+    
+    reconfigure: function(store, columns) {
+        var me = this,
+            headerCt = me.headerCt;
+
+        if (me.lockable) {
+            me.reconfigureLockable(store, columns);
+        } else {
+            Ext.suspendLayouts();
+            if (columns) {
+                
+                delete me.scrollLeftPos;
+                headerCt.removeAll();
+                headerCt.add(columns);
+            }
+            if (store) {
+                store = Ext.StoreManager.lookup(store);
+                me.bindStore(store);
+            } else {
+                me.getView().refresh();
+            }
+            headerCt.setSortState();
+            Ext.resumeLayouts(true);
+        }
+        me.fireEvent('reconfigure', me, store, columns);
+    }
+});
+
+
+Ext.define('Ext.grid.View', {
+    extend: 'Ext.view.Table',
+    alias: 'widget.gridview',
+
+    
+    stripeRows: true,
+
+    autoScroll: true
+});
+
+
+Ext.define('Ext.grid.Panel', {
+    extend: 'Ext.panel.Table',
+    requires: ['Ext.grid.View'],
+    alias: ['widget.gridpanel', 'widget.grid'],
+    alternateClassName: ['Ext.list.ListView', 'Ext.ListView', 'Ext.grid.GridPanel'],
+    viewType: 'gridview',
+
+    lockable: false,
+
+    
+    
+    bothCfgCopy: [
+        'invalidateScrollerOnRefresh',
+        'hideHeaders',
+        'enableColumnHide',
+        'enableColumnMove',
+        'enableColumnResize',
+        'sortableColumns'
+    ],
+    normalCfgCopy: [ 
+        'verticalScroller', 
+        'verticalScrollDock', 
+        'verticalScrollerType', 
+        'scroll'
+    ],
+    lockedCfgCopy: [],
+
+    
+    rowLines: true
+
+    
+    
+
+    
+
+    
+});
+
+
+
+
+
+
+
+
+
+
+Ext.define('Ext.grid.RowEditor', {
+    extend: 'Ext.form.Panel',
+    requires: [
+        'Ext.tip.ToolTip',
+        'Ext.util.HashMap',
+        'Ext.util.KeyNav'
+    ],
+
+    
+    saveBtnText  : 'Update',
+    
+    
+    cancelBtnText: 'Cancel',
+    
+    
+    errorsText: 'Errors',
+    
+    
+    dirtyText: 'You need to commit or cancel your changes',
+    
+
+    lastScrollLeft: 0,
+    lastScrollTop: 0,
+
+    border: false,
+    
+    
+    
+    hideMode: 'offsets',
+
+    initComponent: function() {
+        var me = this,
+            form;
+
+        me.cls = Ext.baseCSSPrefix + 'grid-row-editor';
+
+        me.layout = {
+            type: 'hbox',
+            align: 'middle'
+        };
+
+        
+        
+        me.columns = new Ext.util.HashMap();
+        me.columns.getKey = function(columnHeader) {
+            var f;
+            if (columnHeader.getEditor) {
+                f = columnHeader.getEditor();
+                if (f) {
+                    return f.id;
+                }
+            }
+            return columnHeader.id;
+        };
+        me.mon(me.columns, {
+            add: me.onFieldAdd,
+            remove: me.onFieldRemove,
+            replace: me.onFieldReplace,
+            scope: me
+        });
+
+        me.callParent(arguments);
+
+        if (me.fields) {
+            me.setField(me.fields);
+            delete me.fields;
+        }
+        
+        me.mon(Ext.container.Container.hierarchyEventSource, {
+            scope: me,
+            show: me.repositionIfVisible
+        });
+
+        form = me.getForm();
+        form.trackResetOnLoad = true;
+    },
+
+    onFieldChange: function() {
+        var me = this,
+            form = me.getForm(),
+            valid = form.isValid();
+        if (me.errorSummary && me.isVisible()) {
+            me[valid ? 'hideToolTip' : 'showToolTip']();
+        }
+        me.updateButton(valid);
+        me.isValid = valid;
+    },
+    
+    updateButton: function(valid){
+        var buttons = this.floatingButtons; 
+        if (buttons) {
+            buttons.child('#update').setDisabled(!valid);
+        }    
+    },
+
+    afterRender: function() {
+        var me = this,
+            plugin = me.editingPlugin;
+
+        me.callParent(arguments);
+        me.mon(me.renderTo, 'scroll', me.onCtScroll, me, { buffer: 100 });
+
+        
+        me.mon(me.el, {
+            click: Ext.emptyFn,
+            stopPropagation: true
+        });
+
+        me.el.swallowEvent([
+            'keypress',
+            'keydown'
+        ]);
+
+        me.keyNav = new Ext.util.KeyNav(me.el, {
+            enter: plugin.completeEdit,
+            esc: plugin.onEscKey,
+            scope: plugin
+        });
+
+        me.mon(plugin.view, {
+            beforerefresh: me.onBeforeViewRefresh,
+            refresh: me.onViewRefresh,
+            itemremove: me.onViewItemRemove,
+            scope: me
+        });
+    },
+
+    onBeforeViewRefresh: function(view) {
+        var me = this,
+            viewDom = view.el.dom;
+
+        if (me.el.dom.parentNode === viewDom) {
+            viewDom.removeChild(me.el.dom);
+        }
+    },
+
+    onViewRefresh: function(view) {
+        var me = this,
+            viewDom = view.el.dom,
+            context = me.context,
+            idx;
+
+        viewDom.appendChild(me.el.dom);
+
+        
+        if (context && (idx = context.store.indexOf(context.record)) >= 0) {
+            context.row = view.getNode(idx);
+            me.reposition();
+            if (me.tooltip && me.tooltip.isVisible()) {
+                me.tooltip.setTarget(context.row);
+            }
+        } else {
+            me.editingPlugin.cancelEdit();
+        }
+    },
+
+    onViewItemRemove: function(record, index) {
+        var context = this.context;
+        if (context && record === context.record) {
+            
+            this.editingPlugin.cancelEdit();
+        }
+    },
+
+    onCtScroll: function(e, target) {
+        var me = this,
+            scrollTop  = target.scrollTop,
+            scrollLeft = target.scrollLeft;
+
+        if (scrollTop !== me.lastScrollTop) {
+            me.lastScrollTop = scrollTop;
+            if ((me.tooltip && me.tooltip.isVisible()) || me.hiddenTip) {
+                me.repositionTip();
+            }
+        }
+        if (scrollLeft !== me.lastScrollLeft) {
+            me.lastScrollLeft = scrollLeft;
+            me.reposition();
+        }
+    },
+
+    onColumnAdd: function(column) {
+        if (!column.isGroupHeader) {
+            this.setField(column);
+        }
+    },
+
+    onColumnRemove: function(column) {
+        this.columns.remove(column);
+    },
+
+    onColumnResize: function(column, width) {
+        if (!column.isGroupHeader) {
+            column.getEditor().setWidth(width - 2);
+            this.repositionIfVisible();
+        }
+    },
+
+    onColumnHide: function(column) {
+        if (!column.isGroupHeader) {
+            column.getEditor().hide();
+            this.repositionIfVisible();
+        }
+    },
+
+    onColumnShow: function(column) {
+        var field = column.getEditor();
+        field.setWidth(column.getWidth() - 2).show();
+        this.repositionIfVisible();
+    },
+
+    onColumnMove: function(column, fromIdx, toIdx) {
+        if (!column.isGroupHeader) {
+            var field = column.getEditor();
+            if (this.items.indexOf(field) != toIdx) {
+                this.move(fromIdx, toIdx);
+            }
+        }
+    },
+
+    onFieldAdd: function(map, fieldId, column) {
+        var me = this,
+            colIdx,
+            field;
+
+        if (!column.isGroupHeader) {
+            colIdx = me.editingPlugin.grid.headerCt.getHeaderIndex(column);
+            field = column.getEditor({ xtype: 'displayfield' });
+            me.insert(colIdx, field);
+        }
+    },
+
+    onFieldRemove: function(map, fieldId, column) {
+        var me = this,
+            field,
+            fieldEl;
+
+        if (!column.isGroupHeader) {
+            field = column.getEditor();
+            fieldEl = field.el;
+            me.remove(field, false);
+            if (fieldEl) {
+                fieldEl.remove();
+            }
+        }
+    },
+
+    onFieldReplace: function(map, fieldId, column, oldColumn) {
+        this.onFieldRemove(map, fieldId, oldColumn);
+    },
+
+    clearFields: function() {
+        var map = this.columns,
+            key;
+
+        for (key in map) {
+            if (map.hasOwnProperty(key)) {
+                map.removeAtKey(key);
+            }
+        }
+    },
+
+    getFloatingButtons: function() {
+        var me = this,
+            cssPrefix = Ext.baseCSSPrefix,
+            btnsCss = cssPrefix + 'grid-row-editor-buttons',
+            plugin = me.editingPlugin,
+            minWidth = Ext.panel.Panel.prototype.minButtonWidth,
+            btns;
+
+        if (!me.floatingButtons) {
+            btns = me.floatingButtons = new Ext.Container({
+                renderTpl: [
+                    '<div class="{baseCls}-ml"></div>',
+                    '<div class="{baseCls}-mr"></div>',
+                    '<div class="{baseCls}-bl"></div>',
+                    '<div class="{baseCls}-br"></div>',
+                    '<div class="{baseCls}-bc"></div>',
+                    '{%this.renderContainer(out,values)%}'
+                ],
+                width: 200,
+                renderTo: me.el,
+                baseCls: btnsCss,
+                layout: {
+                    type: 'hbox',
+                    align: 'middle'
+                },
+                defaults: {
+                    flex: 1,
+                    margins: '0 1 0 1'
+                },
+                items: [{
+                    itemId: 'update',
+                    xtype: 'button',
+                    handler: plugin.completeEdit,
+                    scope: plugin,
+                    text: me.saveBtnText,
+                    minWidth: minWidth
+                }, {
+                    xtype: 'button',
+                    handler: plugin.cancelEdit,
+                    scope: plugin,
+                    text: me.cancelBtnText,
+                    minWidth: minWidth
+                }]
+            });
+
+            
+            me.mon(btns.el, {
+                
+                
+                mousedown: Ext.emptyFn,
+                click: Ext.emptyFn,
+                stopEvent: true
+            });
+        }
+        return me.floatingButtons;
+    },
+    
+    repositionIfVisible: function(c){
+        var me = this,
+            view = me.view;
+        
+        
+        
+        if (c && (c == me || !view.isDescendantOf(c))) {
+            return;
+        }
+        
+        if (me.isVisible() && view.isVisible(true)) {
+            me.reposition();    
+        }
+    },
+
+    reposition: function(animateConfig) {
+        var me = this,
+            context = me.context,
+            row = context && Ext.get(context.row),
+            btns = me.getFloatingButtons(),
+            btnEl = btns.el,
+            grid = me.editingPlugin.grid,
+            viewEl = grid.view.el,
+
+            
+            
+            mainBodyWidth = grid.headerCt.getFullWidth(),
+            scrollerWidth = grid.getWidth(),
+
+            
+            
+            width = Math.min(mainBodyWidth, scrollerWidth),
+            scrollLeft = grid.view.el.dom.scrollLeft,
+            btnWidth = btns.getWidth(),
+            left = (width - btnWidth) / 2 + scrollLeft,
+            y, rowH, newHeight,
+
+            invalidateScroller = function() {
+                btnEl.scrollIntoView(viewEl, false);
+                if (animateConfig && animateConfig.callback) {
+                    animateConfig.callback.call(animateConfig.scope || me);
+                }
+            },
+            
+            animObj;
+
+        
+        if (row && Ext.isElement(row.dom)) {
+            
+            
+            row.scrollIntoView(viewEl, false);
+
+            
+            
+            
+            y = row.getXY()[1] - 5;
+            rowH = row.getHeight();
+            newHeight = rowH + (me.editingPlugin.grid.rowLines ? 9 : 10);
+
+            
+            if (me.getHeight() != newHeight) {
+                me.setHeight(newHeight);
+                me.el.setLeft(0);
+            }
+
+            if (animateConfig) {
+                animObj = {
+                    to: {
+                        y: y
+                    },
+                    duration: animateConfig.duration || 125,
+                    listeners: {
+                        afteranimate: function() {
+                            invalidateScroller();
+                            y = row.getXY()[1] - 5;
+                        }
+                    }
+                };
+                me.el.animate(animObj);
+            } else {
+                me.el.setY(y);
+                invalidateScroller();
+            }
+        }
+        if (me.getWidth() != mainBodyWidth) {
+            me.setWidth(mainBodyWidth);
+        }
+        btnEl.setLeft(left);
+    },
+
+    getEditor: function(fieldInfo) {
+        var me = this;
+
+        if (Ext.isNumber(fieldInfo)) {
+            
+            
+            
+            return me.query('>[isFormField]')[fieldInfo];
+        } else if (fieldInfo.isHeader && !fieldInfo.isGroupHeader) {
+            return fieldInfo.getEditor();
+        }
+    },
+
+    removeField: function(field) {
+        var me = this;
+
+        
+        field = me.getEditor(field);
+        me.mun(field, 'validitychange', me.onValidityChange, me);
+
+        
+        
+        me.columns.removeAtKey(field.id);
+        Ext.destroy(field);
+    },
+
+    setField: function(column) {
+        var me = this,
+            i,
+            length, field;
+
+        if (Ext.isArray(column)) {
+            length = column.length;
+
+            for (i = 0; i < length; i++) {
+                me.setField(column[i]);
+            }
+
+            return;
+        }
+
+        
+        field = column.getEditor(null, {
+            xtype: 'displayfield',
+            
+            
+            getModelData: function() {
+                return null;
+            }
+        });
+        field.margins = '0 0 0 2';
+        me.mon(field, 'change', me.onFieldChange, me);
+        
+        if (me.isVisible() && me.context) {
+            if (field.is('displayfield')) {
+                me.renderColumnData(field, me.context.record, column);
+            } else {
+                field.suspendEvents();
+                field.setValue(me.context.record.get(column.dataIndex));
+                field.resumeEvents();
+            }
+        }
+
+        
+        
+        
+        me.columns.add(field.id, column);
+        if (column.hidden) {
+            me.onColumnHide(column);
+        } else if (column.rendered) {
+            
+            me.onColumnShow(column);
+        }
+    },
+
+    loadRecord: function(record) {
+        var me     = this,
+            form   = me.getForm(),
+            fields = form.getFields(),
+            items  = fields.items,
+            length = items.length,
+            i, displayFields,
+            isValid;
+            
+        
+        for (i = 0; i < length; i++) {
+            items[i].suspendEvents();
+        }
+
+        form.loadRecord(record);
+
+        for (i = 0; i < length; i++) {
+            items[i].resumeEvents();
+        }
+
+        isValid = form.isValid();
+        if (me.errorSummary) {
+            if (isValid) {
+                me.hideToolTip();
+            } else {
+                me.showToolTip();
+            }
+        }
+        
+        me.updateButton(isValid);
+
+        
+        displayFields = me.query('>displayfield');
+        length = displayFields.length;
+
+        for (i = 0; i < length; i++) {
+            me.renderColumnData(displayFields[i], record);
+        }
+    },
+
+    renderColumnData: function(field, record, activeColumn) {
+        var me = this,
+            grid = me.editingPlugin.grid,
+            headerCt = grid.headerCt,
+            view = grid.view,
+            store = view.store,
+            column = activeColumn || me.columns.get(field.id),
+            value = record.get(column.dataIndex),
+            renderer = column.editRenderer || column.renderer,
+            metaData,
+            rowIdx,
+            colIdx;
+
+        
+        if (renderer) {
+            metaData = { tdCls: '', style: '' };
+            rowIdx = store.indexOf(record);
+            colIdx = headerCt.getHeaderIndex(column);
+
+            value = renderer.call(
+                column.scope || headerCt.ownerCt,
+                value,
+                metaData,
+                record,
+                rowIdx,
+                colIdx,
+                store,
+                view
+            );
+        }
+
+        field.setRawValue(value);
+        field.resetOriginalValue();
+    },
+
+    beforeEdit: function() {
+        var me = this;
+
+        if (me.isVisible() && me.errorSummary && !me.autoCancel && me.isDirty()) {
+            me.showToolTip();
+            return false;
+        }
+    },
+
+    
+    startEdit: function(record, columnHeader) {
+        var me = this,
+            grid = me.editingPlugin.grid,
+            store = grid.store,
+            context = me.context = Ext.apply(me.editingPlugin.context, {
+                view: grid.getView(),
+                store: store
+            });
+
+        
+        context.grid.getSelectionModel().select(record);
+
+        
+        me.loadRecord(record);
+
+        if (!me.isVisible()) {
+            me.show();
+            me.focusContextCell();
+        } else {
+            me.reposition({
+                callback: this.focusContextCell
+            });
+        }
+    },
+
+    
+    focusContextCell: function() {
+        var field = this.getEditor(this.context.colIdx);
+        if (field && field.focus) {
+            field.focus();
+        }
+    },
+
+    cancelEdit: function() {
+        var me     = this,
+            form   = me.getForm(),
+            fields = form.getFields(),
+            items  = fields.items,
+            length = items.length,
+            i;
+
+        me.hide();
+        form.clearInvalid();
+
+        
+        for (i = 0; i < length; i++) {
+            items[i].suspendEvents();
+        }
+
+        form.reset();
+
+        for (i = 0; i < length; i++) {
+            items[i].resumeEvents();
+        }
+    },
+
+    completeEdit: function() {
+        var me = this,
+            form = me.getForm();
+
+        if (!form.isValid()) {
+            return;
+        }
+
+        form.updateRecord(me.context.record);
+        me.hide();
+        return true;
+    },
+
+    onShow: function() {
+        this.callParent(arguments);
+        this.reposition();
+    },
+
+    onHide: function() {
+        var me = this;
+        me.callParent(arguments);
+        if (me.tooltip) {
+            me.hideToolTip();
+        }
+        if (me.context) {
+            me.context.view.focus();
+            me.context = null;
+        }
+    },
+
+    isDirty: function() {
+        var me = this,
+            form = me.getForm();
+        return form.isDirty();
+    },
+
+    getToolTip: function() {
+        return this.tooltip || (this.tooltip = new Ext.tip.ToolTip({
+            cls: Ext.baseCSSPrefix + 'grid-row-editor-errors',
+            title: this.errorsText,
+            autoHide: false,
+            closable: true,
+            closeAction: 'disable',
+            anchor: 'left'
+        }));
+    },
+
+    hideToolTip: function() {
+        var me = this,
+            tip = me.getToolTip();
+        if (tip.rendered) {
+            tip.disable();
+        }
+        me.hiddenTip = false;
+    },
+
+    showToolTip: function() {
+        var me = this,
+            tip = me.getToolTip(),
+            context = me.context,
+            row = Ext.get(context.row),
+            viewEl = context.grid.view.el;
+
+        tip.setTarget(row);
+        tip.showAt([-10000, -10000]);
+        tip.update(me.getErrors());
+        tip.mouseOffset = [viewEl.getWidth() - row.getWidth() + me.lastScrollLeft + 15, 0];
+        me.repositionTip();
+        tip.doLayout();
+        tip.enable();
+    },
+
+    repositionTip: function() {
+        var me = this,
+            tip = me.getToolTip(),
+            context = me.context,
+            row = Ext.get(context.row),
+            viewEl = context.grid.view.el,
+            viewHeight = viewEl.getHeight(),
+            viewTop = me.lastScrollTop,
+            viewBottom = viewTop + viewHeight,
+            rowHeight = row.getHeight(),
+            rowTop = row.dom.offsetTop,
+            rowBottom = rowTop + rowHeight;
+
+        if (rowBottom > viewTop && rowTop < viewBottom) {
+            tip.show();
+            me.hiddenTip = false;
+        } else {
+            tip.hide();
+            me.hiddenTip = true;
+        }
+    },
+
+    getErrors: function() {
+        var me        = this,
+            dirtyText = !me.autoCancel && me.isDirty() ? me.dirtyText + '<br />' : '',
+            errors    = [],
+            fields    = me.query('>[isFormField]'),
+            length    = fields.length,
+            i;
+
+        function createListItem(e) {
+            return '<li>' + e + '</li>';
+        }
+
+        for (i = 0; i < length; i++) {
+            errors = errors.concat(
+                Ext.Array.map(fields[i].getErrors(), createListItem)
+            );
+        }
+
+        return dirtyText + '<ul>' + errors.join('') + '</ul>';
+    },
+    
+    beforeDestroy: function(){
+        Ext.destroy(this.floatingButtons, this.tooltip);
+        this.callParent();    
+    }
+});
+
+
+Ext.define('Ext.grid.plugin.HeaderResizer', {
+    extend: 'Ext.AbstractPlugin',
+    requires: ['Ext.dd.DragTracker', 'Ext.util.Region'],
+    alias: 'plugin.gridheaderresizer',
+
+    disabled: false,
+
+    config: {
+        
+        dynamic: false
+    },
+
+    colHeaderCls: Ext.baseCSSPrefix + 'column-header',
+
+    minColWidth: 40,
+    maxColWidth: 1000,
+    wResizeCursor: 'col-resize',
+    eResizeCursor: 'col-resize',
+    
+    
+    
+    
+
+    init: function(headerCt) {
+        this.headerCt = headerCt;
+        headerCt.on('render', this.afterHeaderRender, this, {single: true});
+    },
+
+    
+    destroy: function() {
+        if (this.tracker) {
+            this.tracker.destroy();
+        }
+    },
+
+    afterHeaderRender: function() {
+        var headerCt = this.headerCt,
+            el = headerCt.el;
+
+        headerCt.mon(el, 'mousemove', this.onHeaderCtMouseMove, this);
+
+        this.tracker = new Ext.dd.DragTracker({
+            disabled: this.disabled,
+            onBeforeStart: Ext.Function.bind(this.onBeforeStart, this),
+            onStart: Ext.Function.bind(this.onStart, this),
+            onDrag: Ext.Function.bind(this.onDrag, this),
+            onEnd: Ext.Function.bind(this.onEnd, this),
+            tolerance: 3,
+            autoStart: 300,
+            el: el
+        });
+    },
+
+    
+    
+    
+    onHeaderCtMouseMove: function(e, t) {
+        var me = this,
+            prevSiblings,
+            headerEl, overHeader, resizeHeader, resizeHeaderOwnerGrid, ownerGrid;
+
+        if (me.headerCt.dragging) {
+            if (me.activeHd) {
+                me.activeHd.el.dom.style.cursor = '';
+                delete me.activeHd;
+            }
+        } else {
+            headerEl = e.getTarget('.' + me.colHeaderCls, 3, true);
+
+            if (headerEl){
+                overHeader = Ext.getCmp(headerEl.id);
+
+                
+                if (overHeader.isOnLeftEdge(e)) {
+                    resizeHeader = overHeader.previousNode('gridcolumn:not([hidden]):not([isGroupHeader])')
+                    
+                    if (resizeHeader) {
+
+                        ownerGrid = me.headerCt.up('tablepanel');
+                        resizeHeaderOwnerGrid = resizeHeader.up('tablepanel');
+
+                        
+                        
+                        
+                        if (!((resizeHeaderOwnerGrid === ownerGrid) || ((ownerGrid.ownerCt.isXType('tablepanel')) && ownerGrid.ownerCt.view.lockedGrid === resizeHeaderOwnerGrid))) {
+                            resizeHeader = null;
+                        }
+                    }
+                }
+                
+                else if (overHeader.isOnRightEdge(e)) {
+                    resizeHeader = overHeader;
+                }
+                
+                else {
+                    resizeHeader = null;
+                }
+
+                
+                if (resizeHeader) {
+                    
+                    
+                    
+                    if (resizeHeader.isGroupHeader) {
+                        prevSiblings = resizeHeader.getGridColumns();
+                        resizeHeader = prevSiblings[prevSiblings.length - 1];
+                    }
+
+                    
+                    
+                    if (resizeHeader && !(resizeHeader.fixed || (resizeHeader.resizable === false) || me.disabled)) {
+                        me.activeHd = resizeHeader;
+                        overHeader.el.dom.style.cursor = me.eResizeCursor;
+                    }
+                
+                } else {
+                    overHeader.el.dom.style.cursor = '';
+                    delete me.activeHd;
+                }
+            }
+        }
+    },
+
+    
+    onBeforeStart : function(e){
+        var t = e.getTarget();
+        
+        this.dragHd = this.activeHd;
+
+        if (!!this.dragHd && !Ext.fly(t).hasCls(Ext.baseCSSPrefix + 'column-header-trigger') && !this.headerCt.dragging) {
+            
+            this.tracker.constrainTo = this.getConstrainRegion();
+            return true;
+        } else {
+            this.headerCt.dragging = false;
+            return false;
+        }
+    },
+
+    
+    getConstrainRegion: function() {
+        var me       = this,
+            dragHdEl = me.dragHd.el,
+            region   = Ext.util.Region.getRegion(dragHdEl),
+            nextHd;
+
+        
+        
+        if (me.headerCt.forceFit) {
+            nextHd = me.dragHd.nextNode('gridcolumn:not([hidden]):not([isGroupHeader])');
+        }
+
+         return region.adjust(
+            0,
+            me.headerCt.forceFit ? (nextHd ? nextHd.getWidth() - me.minColWidth : 0) : me.maxColWidth - dragHdEl.getWidth(),
+            0,
+            me.minColWidth
+        );
+    },
+
+    
+    
+    onStart: function(e){
+        var me       = this,
+            dragHd   = me.dragHd,
+            dragHdEl = dragHd.el,
+            width    = dragHdEl.getWidth(),
+            headerCt = me.headerCt,
+            t        = e.getTarget(),
+            xy, gridSection, dragHct, firstSection, lhsMarker, rhsMarker, el, offsetLeft, offsetTop, topLeft, markerHeight, top;
+
+        if (me.dragHd && !Ext.fly(t).hasCls(Ext.baseCSSPrefix + 'column-header-trigger')) {
+            headerCt.dragging = true;
+        }
+
+        me.origWidth = width;
+
+        
+        if (!me.dynamic) {
+            xy           = dragHdEl.getXY();
+            gridSection  = headerCt.up('[scrollerOwner]');
+            dragHct      = me.dragHd.up(':not([isGroupHeader])');
+            firstSection = dragHct.up();
+            lhsMarker    = gridSection.getLhsMarker();
+            rhsMarker    = gridSection.getRhsMarker();
+            el           = rhsMarker.parent();
+            offsetLeft   = el.getLocalX();
+            offsetTop    = el.getLocalY();
+            topLeft      = el.translatePoints(xy);
+            markerHeight = firstSection.body.getHeight() + headerCt.getHeight();
+            top = topLeft.top - offsetTop;
+
+            lhsMarker.setTop(top);
+            rhsMarker.setTop(top);
+            lhsMarker.setHeight(markerHeight);
+            rhsMarker.setHeight(markerHeight);
+            lhsMarker.setLeft(topLeft.left - offsetLeft);
+            rhsMarker.setLeft(topLeft.left + width - offsetLeft);
+        }
+    },
+
+    
+    onDrag: function(e){
+        if (!this.dynamic) {
+            var xy          = this.tracker.getXY('point'),
+                gridSection = this.headerCt.up('[scrollerOwner]'),
+                rhsMarker   = gridSection.getRhsMarker(),
+                el          = rhsMarker.parent(),
+                topLeft     = el.translatePoints(xy),
+                offsetLeft  = el.getLocalX();
+
+            rhsMarker.setLeft(topLeft.left - offsetLeft);
+        
+        } else {
+            this.doResize();
+        }
+    },
+
+    onEnd: function(e){
+        this.headerCt.dragging = false;
+        if (this.dragHd) {
+            if (!this.dynamic) {
+                var dragHd      = this.dragHd,
+                    gridSection = this.headerCt.up('[scrollerOwner]'),
+                    lhsMarker   = gridSection.getLhsMarker(),
+                    rhsMarker   = gridSection.getRhsMarker(),
+                    offscreen   = -9999;
+
+                
+                lhsMarker.setLeft(offscreen);
+                rhsMarker.setLeft(offscreen);
+            }
+            this.doResize();
+        }
+    },
+
+    doResize: function() {
+        if (this.dragHd) {
+            var dragHd = this.dragHd,
+                nextHd,
+                offset = this.tracker.getOffset('point');
+
+            
+            if (dragHd.flex) {
+                delete dragHd.flex;
+            }
+
+            Ext.suspendLayouts();
+
+            
+            dragHd.setWidth(this.origWidth + offset[0]);
+ 
+            
+            
+            if (this.headerCt.forceFit) {
+                nextHd = dragHd.nextNode('gridcolumn:not([hidden]):not([isGroupHeader])');
+                if (nextHd) {
+                    delete nextHd.flex;
+                    nextHd.setWidth(nextHd.getWidth() - offset[0]);
+                }
+            }
+
+            
+            Ext.resumeLayouts(true);
+        }
+    },
+
+    disable: function() {
+        this.disabled = true;
+        if (this.tracker) {
+            this.tracker.disable();
+        }
+    },
+
+    enable: function() {
+        this.disabled = false;
+        if (this.tracker) {
+            this.tracker.enable();
+        }
+    }
+});
+
+
+Ext.define('Ext.grid.header.DragZone', {
+    extend: 'Ext.dd.DragZone',
+    colHeaderCls: Ext.baseCSSPrefix + 'column-header',
+    maxProxyWidth: 120,
+
+    constructor: function(headerCt) {
+        this.headerCt = headerCt;
+        this.ddGroup =  this.getDDGroup();
+        this.callParent([headerCt.el]);
+        this.proxy.el.addCls(Ext.baseCSSPrefix + 'grid-col-dd');
+    },
+
+    getDDGroup: function() {
+        return 'header-dd-zone-' + this.headerCt.up('[scrollerOwner]').id;
+    },
+
+    getDragData: function(e) {
+        var header = e.getTarget('.'+this.colHeaderCls),
+            headerCmp,
+            ddel;
+
+        if (header) {
+            headerCmp = Ext.getCmp(header.id);
+            if (!this.headerCt.dragging && headerCmp.draggable && !(headerCmp.isOnLeftEdge(e) || headerCmp.isOnRightEdge(e))) {
+                ddel = document.createElement('div');
+                ddel.innerHTML = Ext.getCmp(header.id).text;
+                return {
+                    ddel: ddel,
+                    header: headerCmp
+                };
+            }
+        }
+        return false;
+    },
+
+    onBeforeDrag: function() {
+        return !(this.headerCt.dragging || this.disabled);
+    },
+
+    onInitDrag: function() {
+        this.headerCt.dragging = true;
+        this.callParent(arguments);
+    },
+
+    onDragDrop: function() {
+        this.headerCt.dragging = false;
+        this.callParent(arguments);
+    },
+
+    afterRepair: function() {
+        this.callParent();
+        this.headerCt.dragging = false;
+    },
+
+    getRepairXY: function() {
+        return this.dragData.header.el.getXY();
+    },
+    
+    disable: function() {
+        this.disabled = true;
+    },
+    
+    enable: function() {
+        this.disabled = false;
+    }
+});
+
+
+Ext.define('Ext.grid.header.DropZone', {
+    extend: 'Ext.dd.DropZone',
+    colHeaderCls: Ext.baseCSSPrefix + 'column-header',
+    proxyOffsets: [-4, -9],
+
+    constructor: function(headerCt){
+        this.headerCt = headerCt;
+        this.ddGroup = this.getDDGroup();
+        this.callParent([headerCt.el]);
+    },
+
+    getDDGroup: function() {
+        return 'header-dd-zone-' + this.headerCt.up('[scrollerOwner]').id;
+    },
+
+    getTargetFromEvent : function(e){
+        return e.getTarget('.' + this.colHeaderCls);
+    },
+
+    getTopIndicator: function() {
+        if (!this.topIndicator) {
+            this.topIndicator = Ext.DomHelper.append(Ext.getBody(), {
+                cls: "col-move-top",
+                html: "&#160;"
+            }, true);
+        }
+        return this.topIndicator;
+    },
+
+    getBottomIndicator: function() {
+        if (!this.bottomIndicator) {
+            this.bottomIndicator = Ext.DomHelper.append(Ext.getBody(), {
+                cls: "col-move-bottom",
+                html: "&#160;"
+            }, true);
+        }
+        return this.bottomIndicator;
+    },
+
+    getLocation: function(e, t) {
+        var x      = e.getXY()[0],
+            region = Ext.fly(t).getRegion(),
+            pos, header;
+
+        if ((region.right - x) <= (region.right - region.left) / 2) {
+            pos = "after";
+        } else {
+            pos = "before";
+        }
+        return {
+            pos: pos,
+            header: Ext.getCmp(t.id),
+            node: t
+        };
+    },
+
+    positionIndicator: function(draggedHeader, node, e){
+        var location = this.getLocation(e, node),
+            header = location.header,
+            pos    = location.pos,
+            nextHd = draggedHeader.nextSibling('gridcolumn:not([hidden])'),
+            prevHd = draggedHeader.previousSibling('gridcolumn:not([hidden])'),
+            topIndicator, bottomIndicator, topAnchor, bottomAnchor,
+            topXY, bottomXY, headerCtEl, minX, maxX,
+            allDropZones, ln, i, dropZone;
+
+        
+        if (!header.draggable && header.getIndex() === 0) {
+            return false;
+        }
+
+        this.lastLocation = location;
+
+        if ((draggedHeader !== header) &&
+            ((pos === "before" && nextHd !== header) ||
+            (pos === "after" && prevHd !== header)) &&
+            !header.isDescendantOf(draggedHeader)) {
+
+            
+            
+            
+            allDropZones = Ext.dd.DragDropManager.getRelated(this);
+            ln = allDropZones.length;
+            i  = 0;
+
+            for (; i < ln; i++) {
+                dropZone = allDropZones[i];
+                if (dropZone !== this && dropZone.invalidateDrop) {
+                    dropZone.invalidateDrop();
+                }
+            }
+
+
+            this.valid = true;
+            topIndicator = this.getTopIndicator();
+            bottomIndicator = this.getBottomIndicator();
+            if (pos === 'before') {
+                topAnchor = 'tl';
+                bottomAnchor = 'bl';
+            } else {
+                topAnchor = 'tr';
+                bottomAnchor = 'br';
+            }
+            topXY = header.el.getAnchorXY(topAnchor);
+            bottomXY = header.el.getAnchorXY(bottomAnchor);
+
+            
+            headerCtEl = this.headerCt.el;
+            minX = headerCtEl.getLeft();
+            maxX = headerCtEl.getRight();
+
+            topXY[0] = Ext.Number.constrain(topXY[0], minX, maxX);
+            bottomXY[0] = Ext.Number.constrain(bottomXY[0], minX, maxX);
+
+            
+            
+            topXY[0] -= 4;
+            topXY[1] -= 9;
+            bottomXY[0] -= 4;
+
+            
+            topIndicator.setXY(topXY);
+            bottomIndicator.setXY(bottomXY);
+            topIndicator.show();
+            bottomIndicator.show();
+        
+        } else {
+            this.invalidateDrop();
+        }
+    },
+
+    invalidateDrop: function() {
+        this.valid = false;
+        this.hideIndicators();
+    },
+
+    onNodeOver: function(node, dragZone, e, data) {
+        var me = this,
+            header = me.headerCt,
+            doPosition = true,
+            from = data.header,
+            to;
+            
+        if (data.header.el.dom === node) {
+            doPosition = false;
+        } else {
+            to = me.getLocation(e, node).header;
+            doPosition = (from.ownerCt === to.ownerCt) || (!from.ownerCt.sealed && !to.ownerCt.sealed);
+        }
+        
+        if (doPosition) {
+            me.positionIndicator(data.header, node, e);
+        } else {
+            me.valid = false;
+        }
+        return me.valid ? me.dropAllowed : me.dropNotAllowed;
+    },
+
+    hideIndicators: function() {
+        this.getTopIndicator().hide();
+        this.getBottomIndicator().hide();
+    },
+
+    onNodeOut: function() {
+        this.hideIndicators();
+    },
+
+    onNodeDrop: function(node, dragZone, e, data) {
+        if (this.valid) {
+            var dragHeader   = data.header,
+                lastLocation = this.lastLocation,
+                targetHeader = lastLocation.header,
+                fromCt       = dragHeader.ownerCt,
+                fromHeader   = dragHeader.up('headercontainer:not(gridcolumn)'),
+                localFromIdx = fromCt.items.indexOf(dragHeader), 
+                toCt         = targetHeader.ownerCt,
+                toHeader     = targetHeader.up('headercontainer:not(gridcolumn)'),
+                localToIdx   = toCt.items.indexOf(targetHeader),
+                headerCt     = this.headerCt,
+                fromIdx      = headerCt.getHeaderIndex(dragHeader),
+                colsToMove   = dragHeader.isGroupHeader ? dragHeader.query(':not([isGroupHeader])').length : 1,
+                toIdx        = headerCt.getHeaderIndex(targetHeader),
+                groupCt,
+                scrollerOwner;
+
+            
+            if (lastLocation.pos === 'after') {
+                localToIdx++;
+                toIdx += targetHeader.isGroupHeader ? targetHeader.query(':not([isGroupHeader])').length : 1;
+            }
+
+            
+            
+            
+            if (fromHeader !== toHeader && fromHeader.lockableInjected && toHeader.lockableInjected && toHeader.lockedCt) {
+                scrollerOwner = fromCt.up('[scrollerOwner]');
+                scrollerOwner.lock(dragHeader, localToIdx);
+
+                
+                this.onNodeDrop(node, dragZone, e, data);
+            } else if (fromHeader !== toHeader && fromHeader.lockableInjected && toHeader.lockableInjected && fromHeader.lockedCt) {
+                scrollerOwner = fromCt.up('[scrollerOwner]');
+                scrollerOwner.unlock(dragHeader, localToIdx);
+
+                
+                this.onNodeDrop(node, dragZone, e, data);
+            }
+            
+            
+            else {
+                this.invalidateDrop();
+
+                
+                
+                if ((fromCt === toCt) && (localToIdx > localFromIdx)) {
+
+                    
+                    localToIdx -= 1;
+                }
+
+                
+                Ext.suspendLayouts();
+
+                
+                if (fromCt !== toCt) {
+                    fromCt.remove(dragHeader, false);
+
+                    
+                    if (fromCt.isGroupHeader) {
+                        if (!fromCt.items.getCount()) {
+                            groupCt = fromCt.ownerCt;
+                            groupCt.remove(fromCt, false);
+                            fromCt.el.dom.parentNode.removeChild(fromCt.el.dom);
+                        }
+                    }
+                }
+
+                
+                if (fromCt === toCt) {
+                    toCt.move(localFromIdx, localToIdx);
+                } else {
+                    toCt.insert(localToIdx, dragHeader);
+                }
+
+                
+                
+                
+                if (toCt.isGroupHeader) {
+                    
+                    if (toCt !== fromCt) {
+                        dragHeader.savedFlex = dragHeader.flex;
+                        delete dragHeader.flex;
+                        dragHeader.width = dragHeader.getWidth();
+                    }
+                } else {
+                    if (dragHeader.savedFlex) {
+                        dragHeader.flex = dragHeader.savedFlex;
+                        delete dragHeader.width;
+                    }
+                }
+
+                
+                headerCt.purgeCache();
+                Ext.resumeLayouts(true);
+                headerCt.onHeaderMoved(dragHeader, colsToMove, fromIdx, toIdx);
+
+                
+                if (!fromCt.items.getCount()) {
+                    fromCt.destroy();
+                }
+            }
+        }
+    }
+});
+
+
+Ext.define('Ext.grid.plugin.HeaderReorderer', {
+    extend: 'Ext.AbstractPlugin',
+    requires: ['Ext.grid.header.DragZone', 'Ext.grid.header.DropZone'],
+    alias: 'plugin.gridheaderreorderer',
+
+    init: function(headerCt) {
+        this.headerCt = headerCt;
+        headerCt.on({
+            render: this.onHeaderCtRender,
+            single: true,
+            scope: this
+        });
+    },
+
+    
+    destroy: function() {
+        Ext.destroy(this.dragZone, this.dropZone);
+    },
+
+    onHeaderCtRender: function() {
+        var me = this;
+        
+        me.dragZone = new Ext.grid.header.DragZone(me.headerCt);
+        me.dropZone = new Ext.grid.header.DropZone(me.headerCt);
+        if (me.disabled) {
+            me.dragZone.disable();
+        }
+    },
+    
+    enable: function() {
+        this.disabled = false;
+        if (this.dragZone) {
+            this.dragZone.enable();
+        }
+    },
+    
+    disable: function() {
+        this.disabled = true;
+        if (this.dragZone) {
+            this.dragZone.disable();
+        }
+    }
+});
+
+
+Ext.define('Ext.grid.header.Container', {
+    extend: 'Ext.container.Container',
+    requires: [
+        'Ext.grid.ColumnLayout',
+        'Ext.grid.plugin.HeaderResizer',
+        'Ext.grid.plugin.HeaderReorderer'
+    ],
+    uses: [
+        'Ext.grid.column.Column',
+        'Ext.menu.Menu',
+        'Ext.menu.CheckItem',
+        'Ext.menu.Separator'
+    ],
+    border: true,
+
+    alias: 'widget.headercontainer',
+
+    baseCls: Ext.baseCSSPrefix + 'grid-header-ct',
+    dock: 'top',
+
+    
+    weight: 100,
+
+    defaultType: 'gridcolumn',
+    
+    detachOnRemove: false,
+
+    
+    defaultWidth: 100,
+    
+    
+
+    
+    sortAscText: 'Sort Ascending',
+    
+    
+    sortDescText: 'Sort Descending',
+    
+    
+    sortClearText: 'Clear Sort',
+    
+    
+    columnsText: 'Columns',
+    
+
+    headerOpenCls: Ext.baseCSSPrefix + 'column-header-open',
+
+    
+    triStateSort: false,
+
+    ddLock: false,
+
+    dragging: false,
+
+    
+
+    
+    sortable: true,
+
+    initComponent: function() {
+        var me = this;
+
+        me.headerCounter = 0;
+        me.plugins = me.plugins || [];
+
+        
+        
+
+        
+        
+        if (!me.isHeader) {
+            if (me.enableColumnResize) {
+                me.resizer = new Ext.grid.plugin.HeaderResizer();
+                me.plugins.push(me.resizer);
+            }
+            if (me.enableColumnMove) {
+                me.reorderer = new Ext.grid.plugin.HeaderReorderer();
+                me.plugins.push(me.reorderer);
+            }
+        }
+
+        
+        if (me.isHeader && !me.items) {
+            me.layout = me.layout || 'auto';
+        }
+        
+        else {
+            me.layout = Ext.apply({
+                type: 'gridcolumn',
+                align: 'stretchmax'
+            }, me.initialConfig.layout);
+        }
+        me.defaults = me.defaults || {};
+        Ext.applyIf(me.defaults, {
+            triStateSort: me.triStateSort,
+            sortable: me.sortable
+        });
+        
+        me.menuTask = new Ext.util.DelayedTask(me.updateMenuDisabledState, me);
+        me.callParent();
+        me.addEvents(
+            
+            'columnresize',
+
+            
+            'headerclick',
+
+            
+            'headertriggerclick',
+
+            
+            'columnmove',
+            
+            'columnhide',
+            
+            'columnshow',
+            
+            'sortchange',
+            
+            'menucreate'
+        );
+    },
+
+    onDestroy: function() {
+        var me = this;
+        
+        me.menuTask.cancel();
+        Ext.destroy(me.resizer, me.reorderer);
+        me.callParent();
+    },
+
+    applyColumnsState: function(columns) {
+        if (!columns || !columns.length) {
+            return;
+        }
+
+        var me     = this,
+            items  = me.items.items,
+            count  = items.length,
+            i      = 0,
+            length = columns.length,
+            c, col, columnState, index;
+
+        for (c = 0; c < length; c++) {
+            columnState = columns[c];
+
+            for (index = count; index--; ) {
+                col = items[index];
+                if (col.getStateId && col.getStateId() == columnState.id) {
+                    
+                    
+                    
+                    
+                    if (i !== index) {
+                        me.moveHeader(index, i);
+                    }
+
+                    if (col.applyColumnState) {
+                        col.applyColumnState(columnState);
+                    }
+                    ++i;
+                    break;
+                }
+            }
+        }
+    },
+
+    getColumnsState: function () {
+        var me = this,
+            columns = [],
+            state;
+
+        me.items.each(function (col) {
+            state = col.getColumnState && col.getColumnState();
+            if (state) {
+                columns.push(state);
+            }
+        });
+
+        return columns;
+    },
+
+    
+    
+    
+    onAdd: function(c) {
+        var me = this,
+            headerCt = me.isHeader ? me.getOwnerHeaderCt() : me;
+
+        if (!c.headerId) {
+            c.headerId = c.initialConfig.id || Ext.id(null, 'header-');
+        }
+
+        if (!c.stateId) {
+            
+            
+            
+            
+            c.stateId = c.initialConfig.id || ('h' + (++me.headerCounter));
+        }
+
+        me.callParent(arguments);
+
+        
+        if (headerCt) {
+            headerCt.purgeCache();
+        }
+    },
+
+    
+    
+    
+    onRemove: function(c) {
+        var me = this,
+            headerCt = me.isHeader ? me.getOwnerHeaderCt() : me;
+
+        me.callParent(arguments);
+        
+
+        
+        if (headerCt) {
+            me.purgeCache();
+        }
+    },
+
+    
+    applyDefaults: function(config) {
+        var ret; 
+        
+        if (config && !config.isComponent && config.xtype == 'rownumberer') {
+            ret = config;
+        } else {
+            ret = this.callParent(arguments);
+            
+            
+            if (!config.isGroupHeader && !('width' in ret) && !ret.flex) {
+                ret.width = this.defaultWidth;
+            }
+        }
+        return ret;
+    },
+
+    afterRender: function() {
+        this.callParent();
+        this.setSortState();
+        
+    },
+    
+    setSortState: function(){
+        var store   = this.up('[store]').store,
+            
+            
+            first = store.getFirstSorter(),
+            hd;
+
+        if (first) {
+            hd = this.down('gridcolumn[dataIndex=' + first.property  +']');
+            if (hd) {
+                hd.setSortState(first.direction, false, true);
+            }
+        } else {
+            this.clearOtherSortStates(null);
+        }
+    },
+    
+    getHeaderMenu: function(){
+        var menu = this.getMenu(),
+            item;
+            
+        if (menu) {
+            item = menu.child('#columnItem');
+            if (item) {
+                return item.menu;
+            }
+        }   
+        return null; 
+    },
+    
+    onHeaderVisibilityChange: function(header, visible){
+        var me = this,
+            menu = me.getHeaderMenu(),
+            item;
+        
+        if (menu) {
+            
+            item = me.getMenuItemForHeader(menu, header);
+            if (item) {
+                item.setChecked(visible, true);
+            }
+            
+            me.menuTask.delay(50);
+        }
+    },
+    
+    
+    getLeafMenuItems: function() {
+        var me = this,
+            columns = me.getGridColumns(),
+            items = [],
+            i = 0,
+            count = 0,
+            len = columns.length,
+            menu = me.getMenu(),
+            item;
+
+        for (; i < len; ++i) {
+            item = columns[i];
+            if (item.hideable) {
+                item = me.getMenuItemForHeader(menu, item);
+                if (item) {
+                    items.push(item);
+                    if (item.checked) {
+                        ++count;
+                    }
+                }
+            } else if (!item.hidden && !item.menuDisabled) {
+                ++count;
+            }
+        }
+
+        return {
+            items: items,
+            checkedCount: count    
+        };
+    },
+    
+    updateMenuDisabledState: function(){
+        var me = this,
+            result = me.getLeafMenuItems(),
+            total = result.checkedCount,
+            items = result.items,
+            len = items.length,
+            i = 0,
+            rootItem = me.getMenu().child('#columnItem');
+            
+        if (total <= 1) {
+            
+            me.disableMenuItems(rootItem, Ext.ComponentQuery.query('[checked=true]', items)[0]);
+        } else {
+            
+            for (; i < len; ++i) {
+                me.setMenuItemState(total, rootItem, items[i]);
+            }
+        }
+    },
+    
+    disableMenuItems: function(rootItem, item){
+        while (item && item != rootItem) {
+            item.disableCheckChange();
+            item = item.parentMenu.ownerItem;
+        }
+    },
+    
+    setMenuItemState: function(total, rootItem, item){
+        var parentMenu,
+            checkedChildren;
+            
+        while (item && item != rootItem) {
+            parentMenu = item.parentMenu;
+            checkedChildren = item.parentMenu.query('[checked=true]:not([menu])').length;
+            item.enableCheckChange();
+            item = parentMenu.ownerItem;
+            if (checkedChildren === total) {
+                
+                break;
+            }
+        }
+        
+        
+        this.disableMenuItems(rootItem, item);
+    },
+    
+    getMenuItemForHeader: function(menu, header){
+        return header ? menu.down('menucheckitem[headerId=' + header.id + ']') : null;
+    },
+
+    onHeaderShow: function(header) {
+        
+        var me = this,
+            gridSection = me.ownerCt;
+
+        me.onHeaderVisibilityChange(header, true);
+
+        
+        
+        if (!header.isGroupHeader) {
+            if (gridSection) {
+                gridSection.onHeaderShow(me, header);
+            }
+        }
+        me.fireEvent('columnshow', me, header);
+    },
+
+    onHeaderHide: function(header) {
+        
+        var me = this,
+            gridSection = me.ownerCt;
+
+        me.onHeaderVisibilityChange(header, false);
+
+        
+        if (!header.isGroupHeader) {
+            if (gridSection) {
+                gridSection.onHeaderHide(me, header);
+            }
+        }
+        me.fireEvent('columnhide', me, header);
+    },
+
+    
+    tempLock: function() {
+        this.ddLock = true;
+        Ext.Function.defer(function() {
+            this.ddLock = false;
+        }, 200, this);
+    },
+
+    onHeaderResize: function(header, w, suppressFocus) {
+        var me = this,
+            view = me.view,
+            gridSection = me.ownerCt;
+
+        
+        if (view && view.table.dom) {
+            me.tempLock();
+            if (gridSection) {
+                gridSection.onHeaderResize(me, header, w);
+            }
+        }
+        me.fireEvent('columnresize', this, header, w);
+    },
+
+    onHeaderClick: function(header, e, t) {
+        header.fireEvent('headerclick', this, header, e, t);
+        this.fireEvent("headerclick", this, header, e, t);
+    },
+
+    onHeaderTriggerClick: function(header, e, t) {
+        
+        var me = this;
+        if (header.fireEvent('headertriggerclick', me, header, e, t) !== false && me.fireEvent("headertriggerclick", me, header, e, t) !== false) {
+            me.showMenuBy(t, header);
+        }
+    },
+
+    showMenuBy: function(t, header) {
+        var menu = this.getMenu(),
+            ascItem  = menu.down('#ascItem'),
+            descItem = menu.down('#descItem'),
+            sortableMth;
+
+        menu.activeHeader = menu.ownerCt = header;
+        menu.setFloatParent(header);
+        
+        header.titleEl.addCls(this.headerOpenCls);
+
+        
+        sortableMth = header.sortable ? 'enable' : 'disable';
+        if (ascItem) {
+            ascItem[sortableMth]();
+        }
+        if (descItem) {
+            descItem[sortableMth]();
+        }
+        menu.showBy(t);
+    },
+
+    
+    onMenuDeactivate: function() {
+        var menu = this.getMenu();
+        
+        menu.activeHeader.titleEl.removeCls(this.headerOpenCls);
+    },
+
+    moveHeader: function(fromIdx, toIdx) {
+
+        
+        this.tempLock();
+        this.onHeaderMoved(this.move(fromIdx, toIdx), 1, fromIdx, toIdx);
+    },
+
+    purgeCache: function() {
+        var me = this;
+        
+        delete me.gridDataColumns;
+        delete me.hideableColumns;
+
+        
+        if (me.menu) {
+            
+            me.menu.hide();
+            me.menu.destroy();
+            delete me.menu;
+        }
+    },
+
+    onHeaderMoved: function(header, colsToMove, fromIdx, toIdx) {
+        var me = this,
+            gridSection = me.ownerCt;
+
+        if (gridSection && gridSection.onHeaderMove) {
+            gridSection.onHeaderMove(me, header, colsToMove, fromIdx, toIdx);
+        }
+        me.fireEvent("columnmove", me, header, fromIdx, toIdx);
+    },
+
+    
+    getMenu: function() {
+        var me = this;
+
+        if (!me.menu) {
+            me.menu = new Ext.menu.Menu({
+                hideOnParentHide: false,  
+                items: me.getMenuItems(),
+                listeners: {
+                    deactivate: me.onMenuDeactivate,
+                    scope: me
+                }
+            });
+            me.updateMenuDisabledState();
+            me.fireEvent('menucreate', me, me.menu);
+        }
+        return me.menu;
+    },
+
+    
+    getMenuItems: function() {
+        var me = this,
+            menuItems = [],
+            hideableColumns = me.enableColumnHide ? me.getColumnMenu(me) : null;
+
+        if (me.sortable) {
+            menuItems = [{
+                itemId: 'ascItem',
+                text: me.sortAscText,
+                cls: Ext.baseCSSPrefix + 'hmenu-sort-asc',
+                handler: me.onSortAscClick,
+                scope: me
+            },{
+                itemId: 'descItem',
+                text: me.sortDescText,
+                cls: Ext.baseCSSPrefix + 'hmenu-sort-desc',
+                handler: me.onSortDescClick,
+                scope: me
+            }];
+        }
+        if (hideableColumns && hideableColumns.length) {
+            menuItems.push('-', {
+                itemId: 'columnItem',
+                text: me.columnsText,
+                cls: Ext.baseCSSPrefix + 'cols-icon',
+                menu: hideableColumns
+            });
+        }
+        return menuItems;
+    },
+
+    
+    onSortAscClick: function() {
+        var menu = this.getMenu(),
+            activeHeader = menu.activeHeader;
+
+        activeHeader.setSortState('ASC');
+    },
+
+    
+    onSortDescClick: function() {
+        var menu = this.getMenu(),
+            activeHeader = menu.activeHeader;
+
+        activeHeader.setSortState('DESC');
+    },
+
+    
+    getColumnMenu: function(headerContainer) {
+        var menuItems = [],
+            i = 0,
+            item,
+            items = headerContainer.query('>gridcolumn[hideable]'),
+            itemsLn = items.length,
+            menuItem;
+
+        for (; i < itemsLn; i++) {
+            item = items[i];
+            menuItem = new Ext.menu.CheckItem({
+                text: item.menuText || item.text,
+                checked: !item.hidden,
+                hideOnClick: false,
+                headerId: item.id,
+                menu: item.isGroupHeader ? this.getColumnMenu(item) : undefined,
+                checkHandler: this.onColumnCheckChange,
+                scope: this
+            });
+            menuItems.push(menuItem);
+
+            
+            
+            item.on({
+                destroy: Ext.Function.bind(menuItem.destroy, menuItem)
+            });
+        }
+        return menuItems;
+    },
+
+    onColumnCheckChange: function(checkItem, checked) {
+        var header = Ext.getCmp(checkItem.headerId);
+        header[checked ? 'show' : 'hide']();
+    },
+
+    
+    getColumnsForTpl: function(flushCache) {
+        var cols    = [],
+            headers   = this.getGridColumns(flushCache),
+            headersLn = headers.length,
+            i = 0,
+            header,
+            width;
+
+        for (; i < headersLn; i++) {
+            header = headers[i];
+
+            if (header.hidden || header.up('headercontainer[hidden=true]')) {
+                width = 0;
+            } else {
+                width = header.getDesiredWidth();
+            }
+            cols.push({
+                dataIndex: header.dataIndex,
+                align: header.align,
+                width: width,
+                id: header.id,
+                cls: header.tdCls,
+                columnId: header.getItemId()
+            });
+        }
+        return cols;
+    },
+
+    
+    getColumnCount: function() {
+        return this.getGridColumns().length;
+    },
+
+    
+    getFullWidth: function(flushCache) {
+        var fullWidth = 0,
+            headers = this.getVisibleGridColumns(flushCache),
+            headersLn = headers.length,
+            i = 0,
+            header;
+           
+
+        for (; i < headersLn; i++) {
+            header = headers[i];
+            
+            if (header.getDesiredWidth) {
+                fullWidth += header.getDesiredWidth() || 0;
+            
+            } else {
+                fullWidth += header.getWidth();
+            }
+        }
+        return fullWidth;
+    },
+
+    
+    clearOtherSortStates: function(activeHeader) {
+        var headers   = this.getGridColumns(),
+            headersLn = headers.length,
+            i         = 0;
+
+        for (; i < headersLn; i++) {
+            if (headers[i] !== activeHeader) {
+                
+                headers[i].setSortState(null, true);
+            }
+        }
+    },
+
+    
+    getVisibleGridColumns: function(refreshCache) {
+        return Ext.ComponentQuery.query(':not([hidden])', this.getGridColumns(refreshCache));
+    }, 
+
+    
+    getGridColumns: function(refreshCache) {
+        var me = this,
+            result = refreshCache ? null : me.gridDataColumns;
+
+        
+        if (!result) {
+            me.gridDataColumns = result = [];
+            me.cascade(function(c) {
+                if ((c !== me) && !c.isGroupHeader) {
+                    result.push(c);
+                }
+            });
+        }
+
+        return result;
+    },
+
+    
+    getHideableColumns: function(refreshCache) {
+        var me = this,
+            result = refreshCache ? null : me.hideableColumns;
+
+        if (!result) {
+            result = me.hideableColumns = me.query('[hideable]');
+        }
+        return result;
+    },
+
+    
+    getHeaderIndex: function(header) {
+        
+        if (header.isGroupHeader) {
+            header = header.down(':not([isgroupHeader])');
+        }
+        return Ext.Array.indexOf(this.getGridColumns(), header);
+    },
+
+    
+    getHeaderAtIndex: function(index) {
+        var columns = this.getGridColumns();
+        return columns.length ? columns[index] : null;
+    },
+
+    
+    getVisibleHeaderClosestToIndex: function(index) {
+        var result = this.getHeaderAtIndex(index);
+        if (result && result.hidden) {
+            result = result.next(':not([hidden])') || result.prev(':not([hidden])');
+        }
+        return result;
+    },
+
+    
+    prepareData: function(data, rowIdx, record, view, panel) {
+        var me        = this,
+            obj       = {},
+            headers   = me.gridDataColumns || me.getGridColumns(),
+            headersLn = headers.length,
+            colIdx    = 0,
+            header,
+            headerId,
+            renderer,
+            value,
+            metaData,
+            store = panel.store;
+
+        for (; colIdx < headersLn; colIdx++) {
+            metaData = {
+                tdCls: '',
+                style: ''
+            };
+            header = headers[colIdx];
+            headerId = header.id;
+            renderer = header.renderer;
+            value = data[header.dataIndex];
+
+            if (typeof renderer == "function") {
+                value = renderer.call(
+                    header.scope || me.ownerCt,
+                    value,
+                    
+                    
+                    metaData,
+                    record,
+                    rowIdx,
+                    colIdx,
+                    store,
+                    view
+                );
+            }
+
+            if (me.markDirty) {
+                obj[headerId + '-modified'] = record.isModified(header.dataIndex) ? Ext.baseCSSPrefix + 'grid-dirty-cell' : '';
+            }
+            obj[headerId+'-tdCls'] = metaData.tdCls;
+            obj[headerId+'-tdAttr'] = metaData.tdAttr;
+            obj[headerId+'-style'] = metaData.style;
+            if (typeof value === 'undefined' || value === null || value === '') {
+                value = header.emptyCellText;
+            }
+            obj[headerId] = value;
+        }
+        return obj;
+    },
+
+    expandToFit: function(header) {
+        var view = this.view;
+        if (view) {
+            view.expandToFit(header);
+        }
+    }
+});
+
+
+Ext.define('Ext.grid.column.Column', {
+    extend: 'Ext.grid.header.Container',
+    alias: 'widget.gridcolumn',
+    requires: ['Ext.util.KeyNav', 'Ext.grid.ColumnComponentLayout', 'Ext.grid.ColumnLayout'],
+    alternateClassName: 'Ext.grid.Column',
+
+    baseCls: Ext.baseCSSPrefix + 'column-header ' + Ext.baseCSSPrefix + 'unselectable',
+
+    
+    hoverCls: Ext.baseCSSPrefix + 'column-header-over',
+
+    handleWidth: 5,
+
+    sortState: null,
+
+    possibleSortStates: ['ASC', 'DESC'],
+
+    childEls: [
+        'titleEl', 'triggerEl', 'textEl'
+    ],
+
+    renderTpl:
+        '<div id="{id}-titleEl" {tipMarkup}class="' + Ext.baseCSSPrefix + 'column-header-inner">' +
+            '<span id="{id}-textEl" class="' + Ext.baseCSSPrefix + 'column-header-text">' +
+                '{text}' +
+            '</span>' +
+            '<tpl if="!menuDisabled">'+
+                '<div id="{id}-triggerEl" class="' + Ext.baseCSSPrefix + 'column-header-trigger"></div>'+
+            '</tpl>' +
+        '</div>' +
+        '{%this.renderContainer(out,values)%}',
+
+    
+
+    
+
+    
+    dataIndex: null,
+
+    
+    text: '&#160;',
+
+    
+
+    
+    menuText: null,
+
+    
+    emptyCellText: '&#160;',
+
+    
+    sortable: true,
+
+    
+
+    
+
+    
+
+    
+    resizable: true,
+
+    
+    hideable: true,
+
+    
+    menuDisabled: false,
+
+    
+    renderer: false,
+
+    
+    
+    
+
+    
+    editRenderer: false,
+
+    
+    align: 'left',
+
+    
+    draggable: true,
+    
+    
+    
+    
+    tooltipType: 'qtip',
+
+    
+    
+    initDraggable: Ext.emptyFn,
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+    isHeader: true,
+
+    componentLayout: 'columncomponent',
+    
+    
+    initResizable: Ext.emptyFn,
+
+    initComponent: function() {
+        var me = this,
+            renderer;
+
+        if (Ext.isDefined(me.header)) {
+            me.text = me.header;
+            delete me.header;
+        }
+
+        if (!me.triStateSort) {
+            me.possibleSortStates.length = 2;
+        }
+
+        
+        if (Ext.isDefined(me.columns)) {
+            me.isGroupHeader = true;
+
+
+            
+            me.items = me.columns;
+            delete me.columns;
+            delete me.flex;
+            delete me.width;
+            me.cls = (me.cls||'') + ' ' + Ext.baseCSSPrefix + 'group-header';
+            me.sortable = false;
+            me.resizable = false;
+            me.align = 'center';
+        } else {
+            
+            
+            me.isContainer = false;
+
+            
+            
+            
+            if (me.flex) {
+                me.minWidth = me.minWidth || Ext.grid.plugin.HeaderResizer.prototype.minColWidth;
+            }
+        }
+        me.addCls(Ext.baseCSSPrefix + 'column-header-align-' + me.align);
+        
+        renderer = me.renderer;
+        if (renderer) {
+            
+            
+            if (typeof renderer == 'string') {
+                me.renderer = Ext.util.Format[renderer];
+            }
+            me.hasCustomRenderer = true;
+        } else if (me.defaultRenderer) {
+            me.scope = me;
+            me.renderer = me.defaultRenderer;
+        }
+
+        
+        me.callParent(arguments);
+
+        me.on({
+            element:  'el',
+            click:    me.onElClick,
+            dblclick: me.onElDblClick,
+            scope:    me
+        });
+        me.on({
+            element:    'titleEl',
+            mouseenter: me.onTitleMouseOver,
+            mouseleave: me.onTitleMouseOut,
+            scope:      me
+        });
+    },
+
+    onAdd: function(childHeader) {
+        childHeader.isSubHeader = true;
+        childHeader.addCls(Ext.baseCSSPrefix + 'group-sub-header');
+        this.callParent(arguments);
+    },
+
+    onRemove: function(childHeader) {
+        childHeader.isSubHeader = false;
+        childHeader.removeCls(Ext.baseCSSPrefix + 'group-sub-header');
+        this.callParent(arguments);
+    },
+
+    initRenderData: function() {
+        var me = this,
+            tipMarkup = '',
+            tip = me.tooltip,
+            attr = me.tooltipType == 'qtip' ? 'data-qtip' : 'title';
+            
+        if (!Ext.isEmpty(tip)) {
+            tipMarkup = attr + '="' + tip + '" ';
+        }
+            
+        return Ext.applyIf(me.callParent(arguments), {
+            text: me.text,
+            menuDisabled: me.menuDisabled,
+            tipMarkup: tipMarkup
+        });
+    },
+
+    applyColumnState: function (state) {
+        var me = this,
+            defined = Ext.isDefined;
+            
+        
+        me.applyColumnsState(state.columns);
+
+        
+        
+        if (defined(state.hidden)) {
+            me.hidden = state.hidden;
+        }
+        if (defined(state.locked)) {
+            me.locked = state.locked;
+        }
+        if (defined(state.sortable)) {
+            me.sortable = state.sortable;
+        }
+        if (defined(state.width)) {
+            delete me.flex;
+            me.width = state.width;
+        } else if (defined(state.flex)) {
+            delete me.width;
+            me.flex = state.flex;
+        }
+    },
+
+    getColumnState: function () {
+        var me = this,
+            items = me.items.items,
+            
+            iLen = items ? items.length : 0,
+            i,
+            columns = [],
+            state = {
+                id: me.getStateId()
+            };
+
+        me.savePropsToState(['hidden', 'sortable', 'locked', 'flex', 'width'], state);
+        
+        if (me.isGroupHeader) {
+            for (i = 0; i < iLen; i++) {
+                columns.push(items[i].getColumnState());
+            }
+
+            if (columns.length) {
+                state.columns = columns;
+            }
+        } else if (me.isSubHeader && me.ownerCt.hidden) {
+            
+            delete me.hidden;
+        }
+
+        if ('width' in state) {
+            delete state.flex; 
+        }
+        return state;
+    },
+
+    getStateId: function () {
+        return this.stateId || this.headerId;
+    },
+
+    
+    setText: function(text) {
+        this.text = text;
+        if (this.rendered) {
+            this.textEl.update(text);
+        }
+    },
+
+    
+    
+    getOwnerHeaderCt: function() {
+        return this.up(':not([isHeader])');
+    },
+
+    
+    getIndex: function() {
+        return this.isGroupColumn ? false : this.getOwnerHeaderCt().getHeaderIndex(this);
+    },
+    
+    
+    getVisibleIndex: function() {
+        return this.isGroupColumn ? false : Ext.Array.indexOf(this.getOwnerHeaderCt().getVisibleGridColumns(), this);
+    },
+
+    beforeRender: function() {
+        var me = this,
+            grid = me.up('tablepanel');
+
+        me.callParent();
+
+        
+        
+        if (grid && (!me.sortable || grid.sortableColumns === false) && !me.groupable &&
+                     !me.lockable && (grid.enableColumnHide === false ||
+                     !me.getOwnerHeaderCt().getHideableColumns().length)) {
+            me.menuDisabled = true;
+        }
+    },
+
+    afterRender: function() {
+        var me = this,
+            el = me.el;
+
+        me.callParent(arguments);
+
+        if (me.overCls) {
+            el.addClsOnOver(me.overCls);
+        }
+
+        
+        
+        if (!Ext.isIE8 || !Ext.isStrict) {
+            me.mon(me.getFocusEl(), {
+                focus: me.onTitleMouseOver,
+                blur: me.onTitleMouseOut,
+                scope: me
+            });
+        }
+
+        me.keyNav = new Ext.util.KeyNav(el, {
+            enter: me.onEnterKey,
+            down: me.onDownKey,
+            scope: me
+        });
+    },
+
+    
+    
+    afterComponentLayout: function(width, height, oldWidth, oldHeight) {
+        var me = this,
+            ownerHeaderCt = me.getOwnerHeaderCt();
+
+        me.callParent(arguments);
+
+        if (ownerHeaderCt && (oldWidth != null || me.flex) && width !== oldWidth) {
+            ownerHeaderCt.onHeaderResize(me, width, true);
+        }
+    },
+
+    
+    
+    
+    setPadding: function(headerHeight) {
+        var me = this,
+            lineHeight = parseInt(me.textEl.getStyle('line-height'), 10),
+            textHeight = me.textEl.dom.offsetHeight,
+            titleEl = me.titleEl,
+            availableHeight = headerHeight - me.el.getBorderWidth('tb'),
+            titleElHeight;
+
+        
+        if (!me.isGroupHeader) {
+            if (titleEl.getHeight() < availableHeight) {
+                titleEl.setHeight(availableHeight);
+                
+                
+                
+                me.ownerCt.layout.innerCt.setHeight(headerHeight);
+            }
+        }
+        titleElHeight = titleEl.getViewSize().height;
+
+        
+        if (textHeight) {
+            if(lineHeight) {
+                textHeight = Math.ceil(textHeight / lineHeight) * lineHeight;
+            }
+            titleEl.setStyle({
+                paddingTop: Math.floor(Math.max(((titleElHeight - textHeight) / 2), 0)) + 'px'
+            });
+        }
+
+        
+        if (Ext.isIE && me.triggerEl) {
+            me.triggerEl.setHeight(titleElHeight);
+        }
+    },
+
+    onDestroy: function() {
+        var me = this;
+        
+        Ext.destroy(me.textEl, me.keyNav, me.field);
+        delete me.keyNav;
+        me.callParent(arguments);
+    },
+
+    onTitleMouseOver: function() {
+        this.titleEl.addCls(this.hoverCls);
+    },
+
+    onTitleMouseOut: function() {
+        this.titleEl.removeCls(this.hoverCls);
+    },
+
+    onDownKey: function(e) {
+        if (this.triggerEl) {
+            this.onElClick(e, this.triggerEl.dom || this.el.dom);
+        }
+    },
+
+    onEnterKey: function(e) {
+        this.onElClick(e, this.el.dom);
+    },
+
+    
+    onElDblClick: function(e, t) {
+        var me = this,
+            ownerCt = me.ownerCt;
+        if (ownerCt && Ext.Array.indexOf(ownerCt.items, me) !== 0 && me.isOnLeftEdge(e) ) {
+            ownerCt.expandToFit(me.previousSibling('gridcolumn'));
+        }
+    },
+
+    onElClick: function(e, t) {
+
+        
+        var me = this,
+            ownerHeaderCt = me.getOwnerHeaderCt();
+
+        if (ownerHeaderCt && !ownerHeaderCt.ddLock) {
+            
+            
+            if (me.triggerEl && (e.target === me.triggerEl.dom || t === me.triggerEl.dom || e.within(me.triggerEl))) {
+                ownerHeaderCt.onHeaderTriggerClick(me, e, t);
+            
+            } else if (e.getKey() || (!me.isOnLeftEdge(e) && !me.isOnRightEdge(e))) {
+                me.toggleSortState();
+                ownerHeaderCt.onHeaderClick(me, e, t);
+            }
+        }
+    },
+
+    
+    processEvent: function(type, view, cell, recordIndex, cellIndex, e) {
+        return this.fireEvent.apply(this, arguments);
+    },
+
+    toggleSortState: function() {
+        var me = this,
+            idx,
+            nextIdx;
+
+        if (me.sortable) {
+            idx = Ext.Array.indexOf(me.possibleSortStates, me.sortState);
+
+            nextIdx = (idx + 1) % me.possibleSortStates.length;
+            me.setSortState(me.possibleSortStates[nextIdx]);
+        }
+    },
+
+    doSort: function(state) {
+        var ds = this.up('tablepanel').store;
+        ds.sort({
+            property: this.getSortParam(),
+            direction: state
+        });
+    },
+
+    
+    getSortParam: function() {
+        return this.dataIndex;
+    },
+
+    
+    
+    setSortState: function(state, skipClear, initial) {
+        var me = this,
+            colSortClsPrefix = Ext.baseCSSPrefix + 'column-header-sort-',
+            ascCls = colSortClsPrefix + 'ASC',
+            descCls = colSortClsPrefix + 'DESC',
+            nullCls = colSortClsPrefix + 'null',
+            ownerHeaderCt = me.getOwnerHeaderCt(),
+            oldSortState = me.sortState;
+
+        if (oldSortState !== state && me.getSortParam()) {
+            me.addCls(colSortClsPrefix + state);
+            
+            if (state && !initial) {
+                me.doSort(state);
+            }
+            switch (state) {
+                case 'DESC':
+                    me.removeCls([ascCls, nullCls]);
+                    break;
+                case 'ASC':
+                    me.removeCls([descCls, nullCls]);
+                    break;
+                case null:
+                    me.removeCls([ascCls, descCls]);
+                    break;
+            }
+            if (ownerHeaderCt && !me.triStateSort && !skipClear) {
+                ownerHeaderCt.clearOtherSortStates(me);
+            }
+            me.sortState = state;
+            
+            if (me.triStateSort || state != null) {
+                ownerHeaderCt.fireEvent('sortchange', ownerHeaderCt, me, state);
+            }
+        }
+    },
+
+    hide: function(fromOwner) {
+        var me = this,
+            ownerHeaderCt = me.getOwnerHeaderCt(),
+            owner = me.ownerCt,
+            ownerIsGroup = owner.isGroupHeader,
+            item, items, len, i;
+
+        
+        if (ownerIsGroup && !fromOwner) {
+            items = owner.query('>:not([hidden])');
+            
+            if (items.length === 1 && items[0] == me) {
+                me.ownerCt.hide();
+                return;
+            }
+        }
+
+        Ext.suspendLayouts();
+
+        if (me.isGroupHeader) {
+            items = me.items.items;
+            for (i = 0, len = items.length; i < len; i++) {
+                item = items[i];
+                if (!item.hidden) {
+                    item.hide(true);
+                }
+            }
+        }
+
+        me.callParent();
+        
+        ownerHeaderCt.onHeaderHide(me);
+
+        Ext.resumeLayouts(true);
+    },
+
+    show: function(fromOwner, fromChild) {
+        var me = this,
+            ownerCt = me.ownerCt,
+            items,
+            len, i,
+            item;
+
+        Ext.suspendLayouts();
+
+        
+        if (me.isSubHeader && ownerCt.hidden) {
+            ownerCt.show(false, true);
+        }
+
+        me.callParent(arguments);
+
+        
+        if (me.isGroupHeader && fromChild !== true && !me.query(':not([hidden])').length) {
+            items = me.query('>*');
+            for (i = 0, len = items.length; i < len; i++) {
+                item = items[i];
+                if (item.hidden) {
+                    item.show(true);
+                }
+            }
+        }
+
+        Ext.resumeLayouts(true);
+
+        
+        ownerCt = me.getOwnerHeaderCt();
+        if (ownerCt) {
+            ownerCt.onHeaderShow(me);
+        }
+    },
+
+    getDesiredWidth: function() {
+        var me = this;
+        if (me.rendered && me.componentLayout && me.componentLayout.lastComponentSize) {
+            
+            
+            
+            
+            
+            
+            return me.componentLayout.lastComponentSize.width;
+        
+        
+        
+        }
+        else if (me.flex) {
+            
+            return me.width;
+        }
+        else {
+            return me.width;
+        }
+    },
+
+    getCellSelector: function() {
+        return '.' + Ext.baseCSSPrefix + 'grid-cell-' + this.getItemId();
+    },
+
+    getCellInnerSelector: function() {
+        return this.getCellSelector() + ' .' + Ext.baseCSSPrefix + 'grid-cell-inner';
+    },
+
+    isOnLeftEdge: function(e) {
+        return (e.getXY()[0] - this.el.getLeft() <= this.handleWidth);
+    },
+
+    isOnRightEdge: function(e) {
+        return (this.el.getRight() - e.getXY()[0] <= this.handleWidth);
+    }
+
+    
+    
+
+    
+    
+});
+
+
+Ext.define('Ext.grid.RowNumberer', {
+    extend: 'Ext.grid.column.Column',
+    alias: 'widget.rownumberer',
+
+    
+    text: "&#160",
+
+    
+    width: 23,
+
+    
+    sortable: false,
+    
+    
+    draggable: false,
+
+    align: 'right',
+
+    constructor : function(config){
+
+        
+        
+        this.width = this.width;
+
+        this.callParent(arguments);
+        if (this.rowspan) {
+            this.renderer = Ext.Function.bind(this.renderer, this);
+        }
+    },
+
+    
+    resizable: false,
+    hideable: false,
+    menuDisabled: true,
+    dataIndex: '',
+    cls: Ext.baseCSSPrefix + 'row-numberer',
+    rowspan: undefined,
+
+    
+    renderer: function(value, metaData, record, rowIdx, colIdx, store) {
+        if (this.rowspan){
+            metaData.cellAttr = 'rowspan="'+this.rowspan+'"';
+        }
+
+        metaData.tdCls = Ext.baseCSSPrefix + 'grid-cell-special';
+        return store.indexOfTotal(record) + 1;
+    }
+});
+
+
+
+Ext.define('Ext.view.DropZone', {
+    extend: 'Ext.dd.DropZone',
+
+    indicatorHtml: '<div class="' + Ext.baseCSSPrefix + 'grid-drop-indicator-left"></div><div class="' + Ext.baseCSSPrefix + 'grid-drop-indicator-right"></div>',
+    indicatorCls: Ext.baseCSSPrefix + 'grid-drop-indicator',
+
+    constructor: function(config) {
+        var me = this;
+        Ext.apply(me, config);
+
+        
+        
+        
+        
+        
+        if (!me.ddGroup) {
+            me.ddGroup = 'view-dd-zone-' + me.view.id;
+        }
+
+        
+        
+        
+        me.callParent([me.view.el]);
+    },
+
+
+
+    fireViewEvent: function() {
+        var me = this,
+            result;
+
+        me.lock();
+        result = me.view.fireEvent.apply(me.view, arguments);
+        me.unlock();
+        return result;
+    },
+
+    getTargetFromEvent : function(e) {
+        var node = e.getTarget(this.view.getItemSelector()),
+            mouseY, nodeList, testNode, i, len, box;
+
+
+
+        if (!node) {
+            mouseY = e.getPageY();
+            for (i = 0, nodeList = this.view.getNodes(), len = nodeList.length; i < len; i++) {
+                testNode = nodeList[i];
+                box = Ext.fly(testNode).getBox();
+                if (mouseY <= box.bottom) {
+                    return testNode;
+                }
+            }
+        }
+        return node;
+    },
+
+    getIndicator: function() {
+        var me = this;
+
+        if (!me.indicator) {
+            me.indicator = new Ext.Component({
+                html: me.indicatorHtml,
+                cls: me.indicatorCls,
+                ownerCt: me.view,
+                floating: true,
+                shadow: false
+            });
+        }
+        return me.indicator;
+    },
+
+    getPosition: function(e, node) {
+        var y      = e.getXY()[1],
+            region = Ext.fly(node).getRegion(),
+            pos;
+
+        if ((region.bottom - y) >= (region.bottom - region.top) / 2) {
+            pos = "before";
+        } else {
+            pos = "after";
+        }
+        return pos;
+    },
+
+    
+    containsRecordAtOffset: function(records, record, offset) {
+        if (!record) {
+            return false;
+        }
+        var view = this.view,
+            recordIndex = view.indexOf(record),
+            nodeBefore = view.getNode(recordIndex + offset),
+            recordBefore = nodeBefore ? view.getRecord(nodeBefore) : null;
+
+        return recordBefore && Ext.Array.contains(records, recordBefore);
+    },
+
+    positionIndicator: function(node, data, e) {
+        var me = this,
+            view = me.view,
+            pos = me.getPosition(e, node),
+            overRecord = view.getRecord(node),
+            draggingRecords = data.records,
+            indicatorY;
+
+        if (!Ext.Array.contains(draggingRecords, overRecord) && (
+            pos == 'before' && !me.containsRecordAtOffset(draggingRecords, overRecord, -1) ||
+            pos == 'after' && !me.containsRecordAtOffset(draggingRecords, overRecord, 1)
+        )) {
+            me.valid = true;
+
+            if (me.overRecord != overRecord || me.currentPosition != pos) {
+
+                indicatorY = Ext.fly(node).getY() - view.el.getY() - 1;
+                if (pos == 'after') {
+                    indicatorY += Ext.fly(node).getHeight();
+                }
+                me.getIndicator().setWidth(Ext.fly(view.el).getWidth()).showAt(0, indicatorY);
+
+                
+                me.overRecord = overRecord;
+                me.currentPosition = pos;
+            }
+        } else {
+            me.invalidateDrop();
+        }
+    },
+
+    invalidateDrop: function() {
+        if (this.valid) {
+            this.valid = false;
+            this.getIndicator().hide();
+        }
+    },
+
+    
+    onNodeOver: function(node, dragZone, e, data) {
+        var me = this;
+
+        if (!Ext.Array.contains(data.records, me.view.getRecord(node))) {
+            me.positionIndicator(node, data, e);
+        }
+        return me.valid ? me.dropAllowed : me.dropNotAllowed;
+    },
+
+    
+    
+    notifyOut: function(node, dragZone, e, data) {
+        var me = this;
+
+        me.callParent(arguments);
+        delete me.overRecord;
+        delete me.currentPosition;
+        if (me.indicator) {
+            me.indicator.hide();
+        }
+    },
+
+    
+    onContainerOver : function(dd, e, data) {
+        var me = this,
+            view = me.view,
+            count = view.store.getCount();
+
+        
+        if (count) {
+            me.positionIndicator(view.getNode(count - 1), data, e);
+        }
+
+        
+        else {
+            delete me.overRecord;
+            delete me.currentPosition;
+            me.getIndicator().setWidth(Ext.fly(view.el).getWidth()).showAt(0, 0);
+            me.valid = true;
+        }
+        return me.dropAllowed;
+    },
+
+    onContainerDrop : function(dd, e, data) {
+        return this.onNodeDrop(dd, null, e, data);
+    },
+
+    onNodeDrop: function(node, dragZone, e, data) {
+        var me = this,
+            dropHandled = false,
+ 
+            
+            
+            
+            
+            
+            dropHandlers = {
+                wait: false,
+                processDrop: function () {
+                    me.invalidateDrop();
+                    me.handleNodeDrop(data, me.overRecord, me.currentPosition);
+                    dropHandled = true;
+                    me.fireViewEvent('drop', node, data, me.overRecord, me.currentPosition);
+                },
+ 
+                cancelDrop: function() {
+                    me.invalidateDrop();
+                    dropHandled = true;
+                }
+            },
+            performOperation = false;
+ 
+        if (me.valid) {
+            performOperation = me.fireViewEvent('beforedrop', node, data, me.overRecord, me.currentPosition, dropHandlers);
+            if (dropHandlers.wait) {
+                return;
+            }
+ 
+            if (performOperation !== false) {
+                
+                if (!dropHandled) {
+                    dropHandlers.processDrop();
+                }
+            }
+        }
+        return performOperation;
+    },
+    
+    destroy: function(){
+        Ext.destroy(this.indicator);
+        delete this.indicator;
+        this.callParent();
+    }
+});
+
+
+Ext.define('Ext.grid.ViewDropZone', {
+    extend: 'Ext.view.DropZone',
+
+    indicatorHtml: '<div class="' + Ext.baseCSSPrefix + 'grid-drop-indicator-left"></div><div class="' + Ext.baseCSSPrefix + 'grid-drop-indicator-right"></div>',
+    indicatorCls: Ext.baseCSSPrefix + 'grid-drop-indicator',
+
+    handleNodeDrop : function(data, record, position) {
+        var view = this.view,
+            store = view.getStore(),
+            index, records, i, len;
+
+        
+        if (data.copy) {
+            records = data.records;
+            data.records = [];
+            for (i = 0, len = records.length; i < len; i++) {
+                data.records.push(records[i].copy(records[i].getId()));
+            }
+        } else {
+            
+            data.view.store.remove(data.records, data.view === view);
+        }
+
+        index = store.indexOf(record);
+
+        
+        if (position !== 'before') {
+            index++;
+        }
+        store.insert(index, data.records);
+        view.getSelectionModel().select(data.records);
+    }
+});
+
+
+Ext.define('Ext.grid.column.Action', {
+    extend: 'Ext.grid.column.Column',
+    alias: ['widget.actioncolumn'],
+    alternateClassName: 'Ext.grid.ActionColumn',
+
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+
+    actionIdRe: new RegExp(Ext.baseCSSPrefix + 'action-col-(\\d+)'),
+
+    
+    altText: '',
+
+    
+    menuText: '<i>Actions</i>',
+
+    sortable: false,
+
+    constructor: function(config) {
+        var me = this,
+            cfg = Ext.apply({}, config),
+            items = cfg.items || [me],
+            hasGetClass,
+            i,
+            len;
+
+
+        me.origRenderer = cfg.renderer || me.renderer;
+        me.origScope = cfg.scope || me.scope;
+        
+        delete me.renderer;
+        delete me.scope;
+        delete cfg.renderer;
+        delete cfg.scope;
+        
+        
+        delete cfg.items;
+        me.callParent([cfg]);
+
+        
+        me.items = items;
+        
+        for (i = 0, len = items.length; i < len; ++i) {
+            if (items[i].getClass) {
+                hasGetClass = true;
+                break;
+            }
+        }
+        
+        
+        if (me.origRenderer || hasGetClass) {
+            me.hasCustomRenderer = true;
+        }
+    },
+    
+    
+    
+    defaultRenderer: function(v, meta){
+        var me = this,
+            prefix = Ext.baseCSSPrefix,
+            scope = me.origScope || me,
+            items = me.items,
+            len = items.length,
+            i = 0,
+            item;
+            
+        
+        v = Ext.isFunction(me.origRenderer) ? me.origRenderer.apply(scope, arguments) || '' : '';
+
+        meta.tdCls += ' ' + Ext.baseCSSPrefix + 'action-col-cell';
+        for (; i < len; i++) {
+            item = items[i];
+            
+            
+            if (!item.hasActionConfiguration) {
+                
+                
+                item.stopSelection = me.stopSelection;
+                item.disable = Ext.Function.bind(me.disableAction, me, [i], 0);
+                item.enable = Ext.Function.bind(me.enableAction, me, [i], 0);
+                item.hasActionConfiguration = true;
+            }
+            
+            v += '<img alt="' + (item.altText || me.altText) + '" src="' + (item.icon || Ext.BLANK_IMAGE_URL) +
+                '" class="' + prefix + 'action-col-icon ' + prefix + 'action-col-' + String(i) + ' ' + (item.disabled ? prefix + 'item-disabled' : ' ') +
+                ' ' + (Ext.isFunction(item.getClass) ? item.getClass.apply(item.scope || scope, arguments) : (item.iconCls || me.iconCls || '')) + '"' +
+                ((item.tooltip) ? ' data-qtip="' + item.tooltip + '"' : '') + ' />';
+        }
+        return v;    
+    },
+
+    
+    enableAction: function(index, silent) {
+        var me = this;
+
+        if (!index) {
+            index = 0;
+        } else if (!Ext.isNumber(index)) {
+            index = Ext.Array.indexOf(me.items, index);
+        }
+        me.items[index].disabled = false;
+        me.up('tablepanel').el.select('.' + Ext.baseCSSPrefix + 'action-col-' + index).removeCls(me.disabledCls);
+        if (!silent) {
+            me.fireEvent('enable', me);
+        }
+    },
+
+    
+    disableAction: function(index, silent) {
+        var me = this;
+
+        if (!index) {
+            index = 0;
+        } else if (!Ext.isNumber(index)) {
+            index = Ext.Array.indexOf(me.items, index);
+        }
+        me.items[index].disabled = true;
+        me.up('tablepanel').el.select('.' + Ext.baseCSSPrefix + 'action-col-' + index).addCls(me.disabledCls);
+        if (!silent) {
+            me.fireEvent('disable', me);
+        }
+    },
+
+    destroy: function() {
+        delete this.items;
+        delete this.renderer;
+        return this.callParent(arguments);
+    },
+
+    
+    processEvent : function(type, view, cell, recordIndex, cellIndex, e, record, row){
+        var me = this,
+            target = e.getTarget(),
+            match,
+            item, fn,
+            key = type == 'keydown' && e.getKey();
+
+        
+        
+        
+        if (key && !Ext.fly(target).findParent(view.cellSelector)) {
+            target = Ext.fly(cell).down('.' + Ext.baseCSSPrefix + 'action-col-icon', true);
+        }
+
+        
+        if (target && (match = target.className.match(me.actionIdRe))) {
+            item = me.items[parseInt(match[1], 10)];
+            if (item) {
+                if (type == 'click' || (key == e.ENTER || key == e.SPACE)) {
+                    fn = item.handler || me.handler;
+                    if (fn && !item.disabled) {
+                        fn.call(item.scope || me.origScope || me, view, recordIndex, cellIndex, item, e, record, row);
+                    }
+                } else if (type == 'mousedown' && item.stopSelection !== false) {
+                    return false;
+                }
+            }
+        }
+        return me.callParent(arguments);
+    },
+
+    cascade: function(fn, scope) {
+        fn.call(scope||this, this);
+    },
+
+    
+    getRefItems: function() {
+        return [];
+    }
+});
+
+
+Ext.define('Ext.grid.column.Boolean', {
+    extend: 'Ext.grid.column.Column',
+    alias: ['widget.booleancolumn'],
+    alternateClassName: 'Ext.grid.BooleanColumn',
+
+    
+    
+    trueText: 'true',
+    
+
+    
+    
+    falseText: 'false',
+    
+
+    
+    undefinedText: '&#160;',
+
+    
+    
+
+    defaultRenderer: function(value){
+        if (value === undefined) {
+            return this.undefinedText;
+        }
+        
+        if (!value || value === 'false') {
+            return this.falseText;
+        }
+        return this.trueText;
+    }
+});
+
+
+Ext.define('Ext.grid.column.Date', {
+    extend: 'Ext.grid.column.Column',
+    alias: ['widget.datecolumn'],
+    requires: ['Ext.Date'],
+    alternateClassName: 'Ext.grid.DateColumn',
+
+    
+    
+    
+
+    initComponent: function(){
+        if (!this.format) {
+            this.format = Ext.Date.defaultFormat;
+        }
+        
+        this.callParent(arguments);
+    },
+    
+    defaultRenderer: function(value){
+        return Ext.util.Format.date(value, this.format);
+    }
+});
+
+
+Ext.define('Ext.grid.column.Number', {
+    extend: 'Ext.grid.column.Column',
+    alias: ['widget.numbercolumn'],
+    requires: ['Ext.util.Format'],
+    alternateClassName: 'Ext.grid.NumberColumn',
+
+    
+    
+    format : '0,000.00',
+    
+
+    
+    
+
+    defaultRenderer: function(value){
+        return Ext.util.Format.number(value, this.format);
+    }
+});
+
+
+Ext.define('Ext.grid.column.Template', {
+    extend: 'Ext.grid.column.Column',
+    alias: ['widget.templatecolumn'],
+    requires: ['Ext.XTemplate'],
+    alternateClassName: 'Ext.grid.TemplateColumn',
+
+    
+    
+    
+
+    initComponent: function(){
+        var me = this;
+        me.tpl = (!Ext.isPrimitive(me.tpl) && me.tpl.compile) ? me.tpl : new Ext.XTemplate(me.tpl);
+        
+        
+        me.hasCustomRenderer = true;
+        me.callParent(arguments);
+    },
+    
+    defaultRenderer: function(value, meta, record) {
+        var data = Ext.apply({}, record.data, record.getAssociatedData());
+        return this.tpl.apply(data);
+    }
+});
+
+
+Ext.define('Ext.grid.feature.Feature', {
+    extend: 'Ext.util.Observable',
+    alias: 'feature.feature',
+
+    
+    isFeature: true,
+
+    
+    disabled: false,
+
+    
+    hasFeatureEvent: true,
+
+    
+    eventPrefix: null,
+
+    
+    eventSelector: null,
+
+    
+    view: null,
+
+    
+    grid: null,
+
+    
+    collectData: false,
+    
+    constructor: function(config) {
+        this.initialConfig = config;
+        this.callParent(arguments);
+    },
+
+    clone: function() {
+        return new this.self(this.initialConfig);
+    },
+
+    init: Ext.emptyFn,
+
+    getFeatureTpl: function() {
+        return '';
+    },
+
+    
+    getFireEventArgs: function(eventName, view, featureTarget, e) {
+        return [eventName, view, featureTarget, e];
+    },
+
+    
+    attachEvents: function() {
+
+    },
+
+    getFragmentTpl: Ext.emptyFn,
+
+    
+    mutateMetaRowTpl: Ext.emptyFn,
+
+    
+    getMetaRowTplFragments: function() {
+        return {};
+    },
+
+    getTableFragments: function() {
+        return {};
+    },
+
+    
+    getAdditionalData: function(data, idx, record, orig) {
+        return {};
+    },
+
+    
+    enable: function() {
+        this.disabled = false;
+    },
+
+    
+    disable: function() {
+        this.disabled = true;
+    }
+
+});
+
+
+Ext.define('Ext.grid.feature.AbstractSummary', {
+    
+    
+
+    extend: 'Ext.grid.feature.Feature',
+    
+    alias: 'feature.abstractsummary',
+
+    
+
+   
+    showSummaryRow: true,
+
+    
+    nestedIdRe: /\{\{id\}([\w\-]*)\}/g,
+
+    
+    init: function() {
+        var me = this;
+
+        
+        me.grid.optimizedColumnMove = false;
+
+        me.view.mon(me.view.store, {
+            update: me.onStoreUpdate,
+            scope: me
+        });
+    },
+
+    
+    onStoreUpdate: function() {
+        var v = this.view;
+        if (this.showSummaryRow) {
+            v.saveScrollState();
+            v.refresh();
+            v.restoreScrollState();
+        }
+    },
+
+    
+    toggleSummaryRow: function(visible){
+        this.showSummaryRow = !!visible;
+    },
+
+    
+    getSummaryFragments: function(){
+        var fragments = {};
+        if (this.showSummaryRow) {
+            Ext.apply(fragments, {
+                printSummaryRow: Ext.bind(this.printSummaryRow, this)
+            });
+        }
+        return fragments;
+    },
+
+    
+    printSummaryRow: function(index){
+        var inner = this.view.getTableChunker().metaRowTpl.join(''),
+            prefix = Ext.baseCSSPrefix;
+
+        inner = inner.replace(prefix + 'grid-row', prefix + 'grid-row-summary');
+        inner = inner.replace('{{id}}', '{gridSummaryValue}');
+        inner = inner.replace(this.nestedIdRe, '{id$1}');  
+        inner = inner.replace('{[this.embedRowCls()]}', '{rowCls}');
+        inner = inner.replace('{[this.embedRowAttr()]}', '{rowAttr}');
+        inner = new Ext.XTemplate(inner, {
+            firstOrLastCls: Ext.view.TableChunker.firstOrLastCls
+        });
+
+        return inner.applyTemplate({
+            columns: this.getPrintData(index)
+        });
+    },
+
+    
+    getColumnValue: function(column, summaryData){
+        var comp     = Ext.getCmp(column.id),
+            value    = summaryData[column.id],
+            renderer = comp.summaryRenderer;
+            
+        if (!value && value !== 0) {
+            value = '\u00a0';
+        }
+
+        if (renderer) {
+            value = renderer.call(
+                comp.scope || this,
+                value,
+                summaryData,
+                column.dataIndex
+            );
+        }
+        return value;
+    },
+
+    
+    getSummary: function(store, type, field, group){
+        if (type) {
+            if (Ext.isFunction(type)) {
+                return store.aggregate(type, null, group);
+            }
+
+            switch (type) {
+                case 'count':
+                    return store.count(group);
+                case 'min':
+                    return store.min(field, group);
+                case 'max':
+                    return store.max(field, group);
+                case 'sum':
+                    return store.sum(field, group);
+                case 'average':
+                    return store.average(field, group);
+                default:
+                    return group ? {} : '';
+                    
+            }
+        }
+    }
+
+});
+
+
+Ext.define('Ext.grid.feature.Chunking', {
+    extend: 'Ext.grid.feature.Feature',
+    alias: 'feature.chunking',
+
+    chunkSize: 20,
+    rowHeight: Ext.isIE ? 27 : 26,
+    visibleChunk: 0,
+    hasFeatureEvent: false,
+    attachEvents: function() {
+        this.view.el.on('scroll', this.onBodyScroll, this, {buffer: 300});
+    },
+
+    onBodyScroll: function(e, t) {
+        var view = this.view,
+            top  = t.scrollTop,
+            nextChunk = Math.floor(top / this.rowHeight / this.chunkSize);
+        if (nextChunk !== this.visibleChunk) {
+
+            this.visibleChunk = nextChunk;
+            view.refresh();
+            view.el.dom.scrollTop = top;
+            
+            view.el.dom.scrollTop = top;
+        }
+    },
+
+    collectData: function(records, preppedRecords, startIndex, fullWidth, o) {
+        
+        
+        var me = this,
+            recordCount = o.rows.length,
+            start = 0,
+            i = 0,
+            visibleChunk = me.visibleChunk,
+            rows,
+            chunkLength,
+            origRows = o.rows;
+
+        delete o.rows;
+        o.chunks = [];
+        for (; start < recordCount; start += me.chunkSize, i++) {
+            if (start + me.chunkSize > recordCount) {
+                chunkLength = recordCount - start;
+            } else {
+                chunkLength = me.chunkSize;
+            }
+            
+            if (i >= visibleChunk - 1 && i <= visibleChunk + 1) {
+                rows = origRows.slice(start, start + me.chunkSize);
+            } else {
+                rows = [];
+            }
+            o.chunks.push({
+                rows: rows,
+                fullWidth: fullWidth,
+                chunkHeight: chunkLength * me.rowHeight
+            });
+        }
+
+        return o;
+    },
+
+    getTableFragments: function() {
+        return {
+            openTableWrap: function() {
+                return '<tpl for="chunks"><div class="' + Ext.baseCSSPrefix + 'grid-chunk" style="height: {chunkHeight}px;">';
+            },
+            closeTableWrap: function() {
+                return '</div></tpl>';
+            }
+        };
+    }
+});
+
+
+Ext.define('Ext.grid.feature.Grouping', {
+    extend: 'Ext.grid.feature.Feature',
+    alias: 'feature.grouping',
+
+    eventPrefix: 'group',
+    eventSelector: '.' + Ext.baseCSSPrefix + 'grid-group-hd',
+    bodySelector: '.' + Ext.baseCSSPrefix + 'grid-group-body',
+
+    constructor: function() {
+        var me = this;
+
+        me.collapsedState = {};
+        me.callParent(arguments);
+    },
+    
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+    groupHeaderTpl: '{columnName}: {name}',
+    
+    
+    depthToIndent: 17,
+
+    collapsedCls: Ext.baseCSSPrefix + 'grid-group-collapsed',
+    hdCollapsedCls: Ext.baseCSSPrefix + 'grid-group-hd-collapsed',
+    hdCollapsibleCls: Ext.baseCSSPrefix + 'grid-group-hd-collapsible',
+
+    
+    
+    groupByText : 'Group by this field',
+    
+    
+    
+    showGroupsText : 'Show in groups',
+    
+
+    
+    hideGroupedHeader : false,
+
+    
+    startCollapsed : false,
+
+    
+    enableGroupingMenu : true,
+
+    
+    enableNoGroups : true,
+
+    
+    collapsible: true,
+
+    enable: function() {
+        var me    = this,
+            view  = me.view,
+            store = view.store,
+            groupToggleMenuItem;
+
+        me.lastGroupField = me.getGroupField();
+
+        if (me.lastGroupIndex) {
+            me.block();
+            store.group(me.lastGroupIndex);
+            me.unblock();
+        }
+        me.callParent();
+        groupToggleMenuItem = me.view.headerCt.getMenu().down('#groupToggleMenuItem');
+        groupToggleMenuItem.setChecked(true, true);
+        me.refreshIf();
+    },
+
+    disable: function() {
+        var me    = this,
+            view  = me.view,
+            store = view.store,
+            remote = store.remoteGroup,
+            groupToggleMenuItem,
+            lastGroup;
+
+        lastGroup = store.groupers.first();
+        if (lastGroup) {
+            me.lastGroupIndex = lastGroup.property;
+            me.block();
+            store.clearGrouping();
+            me.unblock();
+        }
+
+        me.callParent();
+        groupToggleMenuItem = me.view.headerCt.getMenu().down('#groupToggleMenuItem');
+        groupToggleMenuItem.setChecked(true, true);
+        groupToggleMenuItem.setChecked(false, true);
+        me.refreshIf();
+    },
+
+    refreshIf: function() {
+        var ownerCt = this.grid.ownerCt,
+            view = this.view;
+            
+        if (!view.store.remoteGroup && !this.blockRefresh) {
+
+            
+            if (ownerCt && ownerCt.lockable) {
+                ownerCt.view.refresh();
+            } else {
+                view.refresh();
+            }
+        }
+    },
+
+    getFeatureTpl: function(values, parent, x, xcount) {
+        return [
+            '<tpl if="typeof rows !== \'undefined\'">',
+                
+                '<tr id="{groupHeaderId}" class="' + Ext.baseCSSPrefix + 'grid-group-hd {hdCollapsedCls} {collapsibleClass}"><td class="' + Ext.baseCSSPrefix + 'grid-cell" colspan="' + parent.columns.length + '" {[this.indentByDepth(values)]}><div class="' + Ext.baseCSSPrefix + 'grid-cell-inner"><div class="' + Ext.baseCSSPrefix + 'grid-group-title">{collapsed}{[this.renderGroupHeaderTpl(values, parent)]}</div></div></td></tr>',
+                
+                '<tr id="{groupBodyId}" class="' + Ext.baseCSSPrefix + 'grid-group-body {collapsedCls}"><td colspan="' + parent.columns.length + '">{[this.recurse(values)]}</td></tr>',
+            '</tpl>'
+        ].join('');
+    },
+
+    getFragmentTpl: function() {
+        var me = this;
+        return {
+            indentByDepth: me.indentByDepth,
+            depthToIndent: me.depthToIndent,
+            renderGroupHeaderTpl: function(values, parent) {
+                return Ext.XTemplate.getTpl(me, 'groupHeaderTpl').apply(values, parent);
+            }
+        };
+    },
+
+    indentByDepth: function(values) {
+        return 'style="padding-left:'+ ((values.depth || 0) * this.depthToIndent) + 'px;"';
+    },
+
+    
+    
+    destroy: function() {
+        delete this.view;
+        delete this.prunedHeader;
+    },
+
+    
+    attachEvents: function() {
+        var me = this,
+            view = me.view;
+
+        view.on({
+            scope: me,
+            groupclick: me.onGroupClick,
+            rowfocus: me.onRowFocus
+        });
+
+        view.mon(view.store, {
+            scope: me,
+            groupchange: me.onGroupChange,
+            remove: me.onRemove,
+            add: me.onAdd,
+            update: me.onUpdate
+        });
+
+        if (me.enableGroupingMenu) {
+            me.injectGroupingMenu();
+        }
+
+        me.pruneGroupedHeader();
+
+        me.lastGroupField = me.getGroupField();
+        me.block();
+        me.onGroupChange();
+        me.unblock();
+    },
+
+    
+    onAdd: function(store, records){
+        var me = this,
+            view = me.view,
+            groupField = me.getGroupField(),
+            i = 0,
+            len = records.length,
+            activeGroups,
+            addedGroups,
+            groups,
+            needsRefresh,
+            group;
+
+        if (view.rendered) {
+            addedGroups = {};
+            activeGroups = {};
+
+            for (; i < len; ++i) {
+                group = records[i].get(groupField);
+                if (addedGroups[group] === undefined) {
+                    addedGroups[group] = 0;
+                }
+                addedGroups[group] += 1;
+            }
+            groups = store.getGroups();
+            for (i = 0, len = groups.length; i < len; ++i) {
+                group = groups[i];
+                activeGroups[group.name] = group.children.length;
+            }
+
+            for (group in addedGroups) {
+                if (addedGroups[group] === activeGroups[group]) {
+                    needsRefresh = true;
+                    break;
+                }
+            }
+            
+            if (needsRefresh) {
+                view.refresh();
+            }
+        }
+    },
+
+    onUpdate: function(store, record, type, changedFields){
+        var view = this.view;
+        if (view.rendered && !changedFields || Ext.Array.contains(changedFields, this.getGroupField())) {
+            view.refresh();
+        }
+    },
+
+    onRemove: function(store, record) {
+        var me = this,
+            groupField = me.getGroupField(),
+            removedGroup = record.get(groupField),
+            view = me.view;
+
+        if (view.rendered) {
+            
+            if (store.findExact(groupField, removedGroup) === -1) {
+                me.view.refresh(); 
+            }
+        }
+    },
+
+    injectGroupingMenu: function() {
+        var me       = this,
+            headerCt = me.view.headerCt;
+
+        headerCt.showMenuBy = me.showMenuBy;
+        headerCt.getMenuItems = me.getMenuItems();
+    },
+
+    showMenuBy: function(t, header) {
+        var menu = this.getMenu(),
+            groupMenuItem  = menu.down('#groupMenuItem'),
+            groupableMth = header.groupable === false ?  'disable' : 'enable';
+            
+        groupMenuItem[groupableMth]();
+        Ext.grid.header.Container.prototype.showMenuBy.apply(this, arguments);
+    },
+
+    getMenuItems: function() {
+        var me                 = this,
+            groupByText        = me.groupByText,
+            disabled           = me.disabled || !me.getGroupField(),
+            showGroupsText     = me.showGroupsText,
+            enableNoGroups     = me.enableNoGroups,
+            getMenuItems       = me.view.headerCt.getMenuItems;
+
+        
+        return function() {
+
+            
+            
+            var o = getMenuItems.call(this);
+            o.push('-', {
+                iconCls: Ext.baseCSSPrefix + 'group-by-icon',
+                itemId: 'groupMenuItem',
+                text: groupByText,
+                handler: me.onGroupMenuItemClick,
+                scope: me
+            });
+            if (enableNoGroups) {
+                o.push({
+                    itemId: 'groupToggleMenuItem',
+                    text: showGroupsText,
+                    checked: !disabled,
+                    checkHandler: me.onGroupToggleMenuItemClick,
+                    scope: me
+                });
+            }
+            return o;
+        };
+    },
+
+    
+    onGroupMenuItemClick: function(menuItem, e) {
+        var me = this,
+            menu = menuItem.parentMenu,
+            hdr  = menu.activeHeader,
+            view = me.view,
+            store = view.store;
+
+        delete me.lastGroupIndex;
+        me.block();
+        me.enable();
+        store.group(hdr.dataIndex);
+        me.pruneGroupedHeader();
+        me.unblock();
+        me.refreshIf();
+    },
+
+    block: function(){
+        this.blockRefresh = this.view.blockRefresh = true;
+    },
+
+    unblock: function(){
+        this.blockRefresh = this.view.blockRefresh = false;
+    },
+
+    
+    onGroupToggleMenuItemClick: function(menuItem, checked) {
+        this[checked ? 'enable' : 'disable']();
+    },
+
+    
+    pruneGroupedHeader: function() {
+        var me = this,
+            header = me.getGroupedHeader();
+
+        if (me.hideGroupedHeader && header) {
+            if (me.prunedHeader) {
+                me.prunedHeader.show();
+            }
+            me.prunedHeader = header;
+            header.hide();
+        }
+    },
+
+    getGroupedHeader: function(){
+        var groupField = this.getGroupField(),
+            headerCt = this.view.headerCt;
+
+        return groupField ? headerCt.down('[dataIndex=' + groupField + ']') : null;
+    },
+
+    getGroupField: function(){
+        var group = this.view.store.groupers.first();
+        if (group) {
+            return group.property;
+        }
+        return ''; 
+    },
+
+    
+    onRowFocus: function(rowIdx) {
+        var node    = this.view.getNode(rowIdx),
+            groupBd = Ext.fly(node).up('.' + this.collapsedCls);
+
+        if (groupBd) {
+            
+            
+            this.expand(groupBd);
+        }
+    },
+
+    
+    isExpanded: function(groupName) {
+        return (this.collapsedState[groupName] === false);
+    },
+
+    
+    expand: function(groupName, focus,  preventSizeCalculation) {
+        var me = this,
+            view = me.view,
+            groupHeader,
+            groupBody,
+            lockingPartner = me.lockingPartner;
+
+        
+        if (Ext.isString(groupName)) {
+            groupBody = Ext.fly(me.getGroupBodyId(groupName), '_grouping');
+        }
+        
+        else {
+            groupBody = Ext.fly(groupName, '_grouping')
+            groupName = me.getGroupName(groupBody);
+        }
+        groupHeader = Ext.get(me.getGroupHeaderId(groupName));
+
+        
+        if (me.collapsedState[groupName]) {
+            groupBody.removeCls(me.collapsedCls);
+            groupBody.prev().removeCls(me.hdCollapsedCls);
+
+            if (preventSizeCalculation !== true) {
+                view.refreshSize();
+            }
+            view.fireEvent('groupexpand', view, groupHeader, groupName);
+            me.collapsedState[groupName] = false;
+
+            
+            if (lockingPartner) {
+                lockingPartner.expand(groupName, focus, preventSizeCalculation);
+            }
+            if (focus) {
+                groupBody.scrollIntoView(view.el, null, true);
+            }
+        }
+    },
+
+    
+    expandAll: function(){
+        var me   = this,
+            view = me.view,
+            els  = view.el.select(me.eventSelector).elements,
+            e,
+            eLen = els.length;
+
+        for (e = 0; e < eLen; e++) {
+            me.expand(Ext.fly(els[e]).next(), false, true);
+        }
+
+        view.refreshSize();
+    },
+
+    
+    collapse: function(groupName, focus,  preventSizeCalculation) {
+        var me = this,
+            view = me.view,
+            groupHeader,
+            groupBody,
+            lockingPartner = me.lockingPartner;
+
+        
+        if (Ext.isString(groupName)) {
+            groupBody = Ext.fly(me.getGroupBodyId(groupName), '_grouping');
+        }
+        
+        else {
+            groupBody = Ext.fly(groupName, '_grouping')
+            groupName = me.getGroupName(groupBody);
+        }
+        groupHeader = Ext.get(me.getGroupHeaderId(groupName));
+ 
+        
+        if (!me.collapsedState[groupName]) {
+            groupBody.addCls(me.collapsedCls);
+            groupBody.prev().addCls(me.hdCollapsedCls);
+
+            if (preventSizeCalculation !== true) {
+                view.refreshSize();
+            }
+            view.fireEvent('groupcollapse', view, groupHeader, groupName);
+            me.collapsedState[groupName] = true;
+
+            
+            if (lockingPartner) {
+                lockingPartner.collapse(groupName, focus, preventSizeCalculation);
+            }
+            if (focus) {
+                groupHeader.scrollIntoView(view.el, null, true);
+            }
+        }
+    },
+
+    
+    collapseAll: function() {
+        var me     = this,
+            view   = me.view,
+            els    = view.el.select(me.eventSelector).elements,
+            e,
+            eLen   = els.length;
+
+        for (e = 0; e < eLen; e++) {
+            me.collapse(Ext.fly(els[e]).next(), false, true);
+        }
+
+        view.refreshSize();
+    },
+
+    onGroupChange: function(){
+        var me = this,
+            field = me.getGroupField(),
+            menuItem,
+            visibleGridColumns,
+            groupingByLastVisibleColumn;
+
+        if (me.hideGroupedHeader) {
+            if (me.lastGroupField) {
+                menuItem = me.getMenuItem(me.lastGroupField);
+                if (menuItem) {
+                    menuItem.setChecked(true);
+                }
+            }
+            if (field) {
+                visibleGridColumns = me.view.headerCt.getVisibleGridColumns();
+
+                
+                
+                groupingByLastVisibleColumn = ((visibleGridColumns.length === 1) && (visibleGridColumns[0].dataIndex == field));
+                menuItem = me.getMenuItem(field);
+                if (menuItem && !groupingByLastVisibleColumn) {
+                    menuItem.setChecked(false);
+                }
+            }
+        }
+        me.refreshIf();
+        me.lastGroupField = field;
+    },
+
+    
+    getMenuItem: function(dataIndex){
+        var view = this.view,
+            header = view.headerCt.down('gridcolumn[dataIndex=' + dataIndex + ']'),
+            menu = view.headerCt.getMenu();
+
+        return header ? menu.down('menuitem[headerId='+ header.id +']') : null;
+    },
+
+    
+    onGroupClick: function(view, rowElement, groupName, e) {
+        var me = this;
+
+        if (me.collapsible) {
+            if (me.collapsedState[groupName]) {
+                me.expand(groupName);
+            } else {
+                me.collapse(groupName);
+            }
+        }
+    },
+
+    
+    getMetaRowTplFragments: function() {
+        return {
+            isRow: this.isRow,
+            closeRow: this.closeRow
+        };
+    },
+
+    
+    
+    isRow: function() {
+        return '<tpl if="typeof rows === \'undefined\'">';
+    },
+
+    
+    
+    closeRow: function() {
+        return '</tpl>';
+    },
+
+    
+    mutateMetaRowTpl: function(metaRowTpl) {
+        metaRowTpl.unshift('{[this.isRow()]}');
+        metaRowTpl.push('{[this.closeRow()]}');
+    },
+
+    
+    
+    getAdditionalData: function(data, idx, record, orig) {
+        var view = this.view,
+            hCt  = view.headerCt,
+            col  = hCt.items.getAt(0),
+            o = {},
+            tdAttrKey;
+
+        
+        
+        
+        if (col) {
+            tdAttrKey = col.id + '-tdAttr';
+            o[tdAttrKey] = this.indentByDepth(data) + " " + (orig[tdAttrKey] ? orig[tdAttrKey] : '');
+            o.collapsed = 'true';
+            o.data = record.getData();
+        }
+        return o;
+    },
+
+    
+    getGroupRows: function(group, records, preppedRecords, fullWidth) {
+        var me = this,
+            children = group.children,
+            rows = group.rows = [],
+            view = me.view,
+            header = me.getGroupedHeader(),
+            groupField = me.getGroupField(),
+            index = -1,
+            r,
+            rLen = records.length,
+            record;
+            
+        
+        if (view.store.buffered) {
+            me.collapsible = false;
+        }
+            
+        group.viewId = view.id;
+
+        for (r = 0; r < rLen; r++) {
+            record = records[r];
+
+            if (record.get(groupField) == group.name) {
+                index = r;
+            }
+            if (Ext.Array.indexOf(children, record) != -1) {
+                rows.push(Ext.apply(preppedRecords[r], {
+                    depth : 1
+                }));
+            }
+        }
+
+        group.groupField = groupField,
+        group.groupHeaderId = me.getGroupHeaderId(group.name);
+        group.groupBodyId = me.getGroupBodyId(group.name);
+        group.fullWidth = fullWidth;
+        group.columnName = header ? header.text : groupField;
+        group.groupValue = group.name;
+
+        
+        
+        if (header && index > -1) {
+            group.name = group.renderedValue = preppedRecords[index][header.id];
+        }
+        if (me.collapsedState[group.name]) {
+            group.collapsedCls = me.collapsedCls;
+            group.hdCollapsedCls = me.hdCollapsedCls;
+        } else {
+            group.collapsedCls = group.hdCollapsedCls = '';
+        }
+
+        
+        if (me.collapsible) {
+            group.collapsibleClass = me.hdCollapsibleCls;
+        } else {
+            group.collapsibleClass = '';
+        }
+
+        return group;
+    },
+
+    
+    getGroupHeaderId: function(groupName) {
+        return this.view.id + '-hd-' + groupName;
+    },
+
+    
+    getGroupBodyId: function(groupName) {
+        return this.view.id + '-bd-' + groupName;
+    },
+
+    
+    getGroupName: function(element) {
+        var me = this,
+            targetEl;
+                
+        
+        targetEl = Ext.fly(element).findParent(me.eventSelector);
+        if (targetEl) {
+            return targetEl.id.split(this.view.id + '-hd-')[1];
+        }
+
+        
+        targetEl = Ext.fly(element).findParent(me.bodySelector);
+        if (targetEl) {
+            return targetEl.id.split(this.view.id + '-bd-')[1];
+        }
+    },
+
+    
+    collectData: function(records, preppedRecords, startIndex, fullWidth, o) {
+        var me    = this,
+            store = me.view.store,
+            collapsedState = me.collapsedState,
+            collapseGroups,
+            g,
+            groups, gLen, group;
+
+        if (me.startCollapsed) {
+            
+            
+            
+            me.startCollapsed = false;
+            collapseGroups = true;
+        }
+
+        if (!me.disabled && store.isGrouped()) {
+            o.rows = groups = store.getGroups();
+            gLen   = groups.length;
+
+            for (g = 0; g < gLen; g++) {
+                group = groups[g];
+                
+                if (collapseGroups) {
+                    collapsedState[group.name] = true;
+                }
+
+                me.getGroupRows(group, records, preppedRecords, fullWidth);
+            }
+        }
+        return o;
+    },
+
+    
+    
+    
+    
+    getFireEventArgs: function(type, view, targetEl, e) {
+        return [type, view, targetEl, this.getGroupName(targetEl), e];
+    }
+});
+
+
+Ext.define('Ext.grid.feature.GroupingSummary', {
+
+    
+
+    extend: 'Ext.grid.feature.Grouping',
+
+    alias: 'feature.groupingsummary',
+
+    mixins: {
+        summary: 'Ext.grid.feature.AbstractSummary'
+    },
+
+    
+
+    init: function() {
+        this.mixins.summary.init.call(this);
+    },
+
+   
+   getFeatureTpl: function() {
+        var tpl = this.callParent(arguments);
+
+        if (this.showSummaryRow) {
+            
+            tpl = tpl.replace('</tpl>', '');
+            tpl += '{[this.printSummaryRow(xindex)]}</tpl>';
+        }
+        return tpl;
+    },
+
+    
+    getFragmentTpl: function() {
+        var me = this,
+            fragments = me.callParent();
+
+        Ext.apply(fragments, me.getSummaryFragments());
+        if (me.showSummaryRow) {
+            
+            me.summaryGroups = me.view.store.getGroups();
+            me.summaryData = me.generateSummaryData();
+        }
+        return fragments;
+    },
+
+    
+    getPrintData: function(index){
+        var me = this,
+            columns = me.view.headerCt.getColumnsForTpl(),
+            i = 0,
+            length = columns.length,
+            data = [],
+            name = me.summaryGroups[index - 1].name,
+            active = me.summaryData[name],
+            column;
+
+        for (; i < length; ++i) {
+            column = columns[i];
+            column.gridSummaryValue = this.getColumnValue(column, active);
+            data.push(column);
+        }
+        return data;
+    },
+
+    
+    generateSummaryData: function(){
+        var me = this,
+            data = {},
+            remoteData = {},
+            store = me.view.store,
+            groupField = this.getGroupField(),
+            reader = store.proxy.reader,
+            groups = me.summaryGroups,
+            columns = me.view.headerCt.getColumnsForTpl(),
+            remote,
+            i,
+            length,
+            fieldData,
+            root,
+            key,
+            comp,
+            summaryRows,
+            s,
+            sLen,
+            convertedSummaryRow;
+
+        for (i = 0, length = groups.length; i < length; ++i) {
+            data[groups[i].name] = {};
+        }
+
+        
+        if (me.remoteRoot && reader.rawData) {
+            
+            root = reader.root;
+            reader.root = me.remoteRoot;
+            reader.buildExtractors(true);
+            summaryRows = reader.getRoot(reader.rawData);
+            sLen      = summaryRows.length;
+
+            
+            if (!reader.convertRecordData) {
+                reader.buildExtractors();
+            }
+
+            for (s = 0; s < sLen; s++) {
+                convertedSummaryRow = {};
+
+                
+                reader.convertRecordData(convertedSummaryRow, summaryRows[s]);
+                remoteData[convertedSummaryRow[groupField]] = convertedSummaryRow;
+            }
+
+            
+            reader.root = root;
+            reader.buildExtractors(true);
+        }
+
+        for (i = 0, length = columns.length; i < length; ++i) {
+            comp = Ext.getCmp(columns[i].id);
+            fieldData = me.getSummary(store, comp.summaryType, comp.dataIndex, true);
+
+            for (key in fieldData) {
+                if (fieldData.hasOwnProperty(key)) {
+                    data[key][comp.id] = fieldData[key];
+                }
+            }
+
+            for (key in remoteData) {
+                if (remoteData.hasOwnProperty(key)) {
+                    remote = remoteData[key][comp.dataIndex];
+                    if (remote !== undefined && data[key] !== undefined) {
+                        data[key][comp.id] = remote;
+                    }
+                }
+            }
+        }
+        return data;
+    }
+});
+
+
+Ext.define('Ext.grid.feature.RowBody', {
+    extend: 'Ext.grid.feature.Feature',
+    alias: 'feature.rowbody',
+    rowBodyHiddenCls: Ext.baseCSSPrefix + 'grid-row-body-hidden',
+    rowBodyTrCls: Ext.baseCSSPrefix + 'grid-rowbody-tr',
+    rowBodyTdCls: Ext.baseCSSPrefix + 'grid-cell-rowbody',
+    rowBodyDivCls: Ext.baseCSSPrefix + 'grid-rowbody',
+
+    eventPrefix: 'rowbody',
+    eventSelector: '.' + Ext.baseCSSPrefix + 'grid-rowbody-tr',
+    
+    getRowBody: function(values) {
+        return [
+            '<tr class="' + this.rowBodyTrCls + ' {rowBodyCls}">',
+                '<td class="' + this.rowBodyTdCls + '" colspan="{rowBodyColspan}">',
+                    '<div class="' + this.rowBodyDivCls + '">{rowBody}</div>',
+                '</td>',
+            '</tr>'
+        ].join('');
+    },
+    
+    
+    getMetaRowTplFragments: function() {
+        return {
+            getRowBody: this.getRowBody,
+            rowBodyTrCls: this.rowBodyTrCls,
+            rowBodyTdCls: this.rowBodyTdCls,
+            rowBodyDivCls: this.rowBodyDivCls
+        };
+    },
+
+    mutateMetaRowTpl: function(metaRowTpl) {
+        metaRowTpl.push('{[this.getRowBody(values)]}');
+    },
+
+    
+    getAdditionalData: function(data, idx, record, orig) {
+        var headerCt = this.view.headerCt,
+            colspan  = headerCt.getColumnCount();
+
+        return {
+            rowBody: "",
+            rowBodyCls: this.rowBodyCls,
+            rowBodyColspan: colspan
+        };
+    }
+});
+
+
+Ext.define('Ext.grid.feature.RowWrap', {
+    extend: 'Ext.grid.feature.Feature',
+    alias: 'feature.rowwrap',
+
+    
+    hasFeatureEvent: false,
+
+    init: function() {
+        if (!this.disabled) {
+            this.enable();
+        }
+    },
+
+    getRowSelector: function(){
+        return 'tr:has(> ' + this.view.cellSelector + ')';
+    },
+
+    enable: function(){
+        var me = this,
+            view = me.view;
+
+        me.callParent();
+        
+        me.savedRowSelector = view.rowSelector;
+        view.rowSelector = me.getRowSelector();
+
+        
+        
+        
+        view.getComponentLayout().getColumnSelector = me.getColumnSelector;
+    },
+
+    disable: function(){
+        var me = this,
+            view = me.view,
+            saved = me.savedRowSelector;
+
+        me.callParent();
+        if (saved) {
+            view.rowSelector = saved;
+        }
+        delete me.savedRowSelector;
+    },
+
+    mutateMetaRowTpl: function(metaRowTpl) {  
+        var prefix = Ext.baseCSSPrefix;      
+        
+        
+        metaRowTpl[0] = metaRowTpl[0].replace(prefix + 'grid-row', '');
+        metaRowTpl[0] = metaRowTpl[0].replace("{[this.embedRowCls()]}", "");
+        
+        metaRowTpl.unshift('<table class="' + prefix + 'grid-table ' + prefix + 'grid-table-resizer" style="width: {[this.embedFullWidth()]}px;">');
+        
+        metaRowTpl.unshift('<tr class="' + prefix + 'grid-row {[this.embedRowCls()]}"><td colspan="{[this.embedColSpan()]}"><div class="' + prefix + 'grid-rowwrap-div">');
+
+        
+        metaRowTpl.push('</table>');
+        
+        metaRowTpl.push('</div></td></tr>');
+    },
+
+    embedColSpan: function() {
+        return '{colspan}';
+    },
+
+    embedFullWidth: function() {
+        return '{fullWidth}';
+    },
+
+    getAdditionalData: function(data, idx, record, orig) {
+        var headerCt = this.view.headerCt,
+            colspan  = headerCt.getColumnCount(),
+            fullWidth = headerCt.getFullWidth(),
+            items    = headerCt.query('gridcolumn'),
+            itemsLn  = items.length,
+            i = 0,
+            o = {
+                colspan: colspan,
+                fullWidth: fullWidth
+            },
+            id,
+            tdClsKey,
+            colResizerCls;
+
+        for (; i < itemsLn; i++) {
+            id = items[i].id;
+            tdClsKey = id + '-tdCls';
+            colResizerCls = Ext.baseCSSPrefix + 'grid-col-resizer-'+id;
+            
+            
+            
+            o[tdClsKey] = colResizerCls + " " + (orig[tdClsKey] ? orig[tdClsKey] : '');
+            
+            o[id+'-tdAttr'] = " style=\"width: " + (items[i].hidden ? 0 : items[i].getDesiredWidth()) + "px;\" ";
+            if (orig[id+'-tdAttr']) {
+                o[id+'-tdAttr'] += orig[id+'-tdAttr'];
+            }
+        }
+
+        return o;
+    },
+
+    getMetaRowTplFragments: function() {
+        return {
+            embedFullWidth: this.embedFullWidth,
+            embedColSpan: this.embedColSpan
+        };
+    },
+
+    getColumnSelector: function(header) {
+        var s = Ext.baseCSSPrefix + 'grid-col-resizer-' + header.id;
+        return 'th.' + s + ',td.' + s;
+    }
+});
+
+
+Ext.define('Ext.grid.feature.Summary', {
+    
+    
+    
+    extend: 'Ext.grid.feature.AbstractSummary',
+    
+    alias: 'feature.summary',
+    
+    
+    
+    
+    getFragmentTpl: function() {
+        
+        this.summaryData = this.generateSummaryData(); 
+        return this.getSummaryFragments();
+    },
+    
+    
+    getTableFragments: function(){
+        if (this.showSummaryRow) {
+            return {
+                closeRows: this.closeRows
+            };
+        }
+    },
+    
+    
+    closeRows: function() {
+        return '</tpl>{[this.printSummaryRow()]}';
+    },
+    
+    
+    getPrintData: function(index){
+        var me = this,
+            columns = me.view.headerCt.getColumnsForTpl(),
+            i = 0,
+            length = columns.length,
+            data = [],
+            active = me.summaryData,
+            column;
+            
+        for (; i < length; ++i) {
+            column = columns[i];
+            column.gridSummaryValue = this.getColumnValue(column, active);
+            data.push(column);
+        }
+        return data;
+    },
+    
+    
+    generateSummaryData: function(){
+        var me = this,
+            data = {},
+            store = me.view.store,
+            columns = me.view.headerCt.getColumnsForTpl(),
+            i = 0,
+            length = columns.length,
+            fieldData,
+            key,
+            comp;
+            
+        for (i = 0, length = columns.length; i < length; ++i) {
+            comp = Ext.getCmp(columns[i].id);
+            data[comp.id] = me.getSummary(store, comp.summaryType, comp.dataIndex, false);
+        }
+        return data;
+    }
+});
+
+
+Ext.define('Ext.grid.plugin.Editing', {
+    alias: 'editing.editing',
+    extend: 'Ext.AbstractPlugin',
+
+    requires: [
+        'Ext.grid.column.Column',
+        'Ext.util.KeyNav'
+    ],
+
+    mixins: {
+        observable: 'Ext.util.Observable'
+    },
+
+    
+    clicksToEdit: 2,
+
+    
+    triggerEvent: undefined,
+
+    
+    defaultFieldXType: 'textfield',
+
+    
+    editStyle: '',
+
+    constructor: function(config) {
+        var me = this;
+
+        me.addEvents(
+            
+            'beforeedit',
+
+            
+            'edit',
+
+            
+            'validateedit',
+            
+            'canceledit'
+
+        );
+        me.callParent(arguments);
+        me.mixins.observable.constructor.call(me);
+        
+        me.on("edit", function(editor, e) {
+            me.fireEvent("afteredit", editor, e);
+        });
+    },
+
+    
+    init: function(grid) {
+        var me = this;
+
+        me.grid = grid;
+        me.view = grid.view;
+        me.initEvents();
+        me.mon(grid, 'reconfigure', me.onReconfigure, me);
+        me.onReconfigure();
+
+        grid.relayEvents(me, [
+            
+            'beforeedit',
+            
+            'edit',
+            
+            'validateedit',
+            
+            'canceledit'
+        ]);
+        
+        
+        grid.isEditable = true;
+        grid.editingPlugin = grid.view.editingPlugin = me;
+    },
+
+    
+    onReconfigure: function() {
+        this.initFieldAccessors(this.view.getGridColumns());
+    },
+
+    
+    destroy: function() {
+        var me = this,
+            grid = me.grid;
+
+        Ext.destroy(me.keyNav);
+        me.removeFieldAccessors(grid.getView().getGridColumns());
+
+        
+        me.clearListeners();
+
+        delete me.grid.editingPlugin;
+        delete me.grid.view.editingPlugin;
+        delete me.grid;
+        delete me.view;
+        delete me.editor;
+        delete me.keyNav;
+    },
+
+    
+    getEditStyle: function() {
+        return this.editStyle;
+    },
+
+    
+    initFieldAccessors: function(columns) {
+        columns = [].concat(columns);
+
+        var me   = this,
+            c,
+            cLen = columns.length,
+            column;
+
+        for (c = 0; c < cLen; c++) {
+            column = columns[c];
+
+            Ext.applyIf(column, {
+                getEditor: function(record, defaultField) {
+                    return me.getColumnField(this, defaultField);
+                },
+
+                setEditor: function(field) {
+                    me.setColumnField(this, field);
+                }
+            });
+        }
+    },
+
+    
+    removeFieldAccessors: function(columns) {
+        columns = [].concat(columns);
+
+        var c,
+            cLen = columns.length,
+            column;
+
+        for (c = 0; c < cLen; c++) {
+            column = columns[c];
+
+            delete column.getEditor;
+            delete column.setEditor;
+        }
+    },
+
+    
+    
+    getColumnField: function(columnHeader, defaultField) {
+        var field = columnHeader.field;
+
+        if (!field && columnHeader.editor) {
+            field = columnHeader.editor;
+            delete columnHeader.editor;
+        }
+
+        if (!field && defaultField) {
+            field = defaultField;
+        }
+
+        if (field) {
+            if (Ext.isString(field)) {
+                field = { xtype: field };
+            }
+            if (!field.isFormField) {
+                field = Ext.ComponentManager.create(field, this.defaultFieldXType);
+            }
+            columnHeader.field = field;
+ 
+            Ext.apply(field, {
+                name: columnHeader.dataIndex
+            });
+
+            return field;
+        }
+    },
+
+    
+    
+    setColumnField: function(column, field) {
+        if (Ext.isObject(field) && !field.isFormField) {
+            field = Ext.ComponentManager.create(field, this.defaultFieldXType);
+        }
+        column.field = field;
+    },
+
+    
+    initEvents: function() {
+        var me = this;
+        me.initEditTriggers();
+        me.initCancelTriggers();
+    },
+
+    
+    initCancelTriggers: Ext.emptyFn,
+    
+    
+    initEditTriggers: function() {
+        var me = this,
+            view = me.view;
+
+        
+        if (me.triggerEvent == 'cellfocus') {
+            me.mon(view, 'cellfocus', me.onCellFocus, me);
+        } else if (me.triggerEvent == 'rowfocus') {
+            me.mon(view, 'rowfocus', me.onRowFocus, me);
+        } else {
+
+            
+            
+            
+            
+            
+            
+            if (view.selModel.isCellModel) {
+                view.onCellFocus = Ext.Function.bind(me.beforeViewCellFocus, me);
+            }
+
+            
+            me.mon(view, me.triggerEvent || ('cell' + (me.clicksToEdit === 1 ? 'click' : 'dblclick')), me.onCellClick, me);
+        }
+        
+        
+        
+        me.initAddRemoveHeaderEvents()
+        
+        view.on('render', me.initKeyNavHeaderEvents, me, {single: true});
+    },
+
+    
+    beforeViewCellFocus: function(position) {
+        
+        if (this.view.selModel.keyNavigation || !this.editing || !this.isCellEditable || !this.isCellEditable(position.row, position.columnHeader)) {
+            this.view.focusCell.apply(this.view, arguments);
+        }
+    },
+
+    
+    onRowFocus: function(record, row, rowIdx) {
+        this.startEdit(row, 0);
+    },
+
+    
+    onCellFocus: function(record, cell, position) {
+        this.startEdit(position.row, position.column);
+    },
+
+    
+    onCellClick: function(view, cell, colIdx, record, row, rowIdx, e) {
+        
+        if(!view.expanderSelector || !e.getTarget(view.expanderSelector)) {
+            this.startEdit(record, view.getHeaderAtIndex(colIdx));
+        }
+    },
+
+    initAddRemoveHeaderEvents: function(){
+        var me = this;
+        me.mon(me.grid.headerCt, {
+            scope: me,
+            add: me.onColumnAdd,
+            remove: me.onColumnRemove
+        });
+    },
+
+    initKeyNavHeaderEvents: function() {
+        var me = this;
+
+        me.keyNav = Ext.create('Ext.util.KeyNav', me.view.el, {
+            enter: me.onEnterKey,
+            esc: me.onEscKey,
+            scope: me
+        });
+    },
+    
+    
+    onColumnAdd: function(ct, column) {
+        if (column.isHeader) {
+            this.initFieldAccessors(column);
+        }
+    },
+
+    
+    onColumnRemove: function(ct, column) {
+        if (column.isHeader) {
+            this.removeFieldAccessors(column);
+        }
+    },
+
+    
+    onEnterKey: function(e) {
+        var me = this,
+            grid = me.grid,
+            selModel = grid.getSelectionModel(),
+            record,
+            pos,
+            columnHeader = grid.headerCt.getHeaderAtIndex(0);
+
+        
+        
+        if (selModel.getCurrentPosition) {
+            pos = selModel.getCurrentPosition();
+            if (pos) {
+                record = grid.store.getAt(pos.row);
+                columnHeader = grid.headerCt.getHeaderAtIndex(pos.column);
+            }
+        }
+        
+        else {
+            record = selModel.getLastSelected();
+        }
+
+        
+        if (record && columnHeader) {
+            me.startEdit(record, columnHeader);
+        }
+    },
+
+    
+    onEscKey: function(e) {
+        this.cancelEdit();
+    },
+
+    
+    beforeEdit: Ext.emptyFn,
+
+    
+    startEdit: function(record, columnHeader) {
+        var me = this,
+            context = me.getEditingContext(record, columnHeader);
+
+        if (context == null || me.beforeEdit(context) === false || me.fireEvent('beforeedit', me, context) === false || context.cancel || !me.grid.view.isVisible(true)) {
+            return false;
+        }
+
+        me.context = context;
+
+        
+        me.editing = true;
+    },
+
+    
+    
+    getEditingContext: function(record, columnHeader) {
+        var me = this,
+            grid = me.grid,
+            view = grid.getView(),
+            node = view.getNode(record),
+            rowIdx, colIdx;
+
+        
+        if (!node) {
+            return;
+        }
+
+        
+        columnHeader = grid.headerCt.getVisibleHeaderClosestToIndex(Ext.isNumber(columnHeader) ? columnHeader : columnHeader.getIndex());
+
+        
+        if (!columnHeader) {
+            return;
+        }
+
+        colIdx = columnHeader.getIndex();
+
+        if (Ext.isNumber(record)) {
+            
+            rowIdx = record;
+            record = view.getRecord(node);
+        } else {
+            rowIdx = view.indexOf(node);
+        }
+
+        return {
+            grid   : grid,
+            record : record,
+            field  : columnHeader.dataIndex,
+            value  : record.get(columnHeader.dataIndex),
+            row    : view.getNode(rowIdx),
+            column : columnHeader,
+            rowIdx : rowIdx,
+            colIdx : colIdx
+        };
+    },
+
+    
+    cancelEdit: function() {
+        var me = this;
+
+        me.editing = false;
+        me.fireEvent('canceledit', me, me.context);
+    },
+
+    
+    completeEdit: function() {
+        var me = this;
+
+        if (me.editing && me.validateEdit()) {
+            me.fireEvent('edit', me, me.context);
+        }
+
+        delete me.context;
+        me.editing = false;
+    },
+
+    
+    validateEdit: function() {
+        var me = this,
+            context = me.context;
+
+        return me.fireEvent('validateedit', me, context) !== false && !context.cancel;
+    }
+});
+
+
+Ext.define('Ext.grid.plugin.CellEditing', {
+    alias: 'plugin.cellediting',
+    extend: 'Ext.grid.plugin.Editing',
+    requires: ['Ext.grid.CellEditor', 'Ext.util.DelayedTask'],
+
+    constructor: function() {
+        
+        
+        
+        
+
+        this.callParent(arguments);
+        this.editors = new Ext.util.MixedCollection(false, function(editor) {
+            return editor.editorId;
+        });
+        this.editTask = new Ext.util.DelayedTask();
+    },
+
+    onReconfigure: function(){
+        this.editors.clear();
+        this.callParent();    
+    },
+
+    
+    destroy: function() {
+        var me = this;
+        me.editTask.cancel();
+        me.editors.each(Ext.destroy, Ext);
+        me.editors.clear();
+        me.callParent(arguments);
+    },
+    
+    onBodyScroll: function() {
+        var me = this,
+            ed = me.getActiveEditor(),
+            scroll = me.view.el.getScroll();
+
+        
+        if (ed && ed.editing) {
+            
+            if (scroll.top !== me.scroll.top) {
+                if (ed.field) {
+                    if (ed.field.triggerBlur) {
+                        ed.field.triggerBlur();
+                    } else {
+                        ed.field.blur();
+                    }
+                }
+            }
+            
+            else {
+                 ed.realign();
+            }
+        }
+        me.scroll = scroll;
+    },
+
+    
+    
+    initCancelTriggers: function() {
+        var me   = this,
+            grid = me.grid,
+            view = grid.view;
+            
+        view.addElListener('mousewheel', me.cancelEdit, me);
+        me.mon(view, 'bodyscroll', me.onBodyScroll, me);
+        me.mon(grid, {
+            columnresize: me.cancelEdit,
+            columnmove: me.cancelEdit,
+            scope: me
+        });
+    },
+
+    isCellEditable: function(record, columnHeader) {
+        var me = this,
+            context = me.getEditingContext(record, columnHeader);
+
+        if (me.grid.view.isVisible(true) && context) {
+            columnHeader = context.column;
+            record = context.record;
+            if (columnHeader && me.getEditor(record, columnHeader)) {
+                return true;
+            }
+        }
+    },
+
+    
+    startEdit: function(record, columnHeader) {
+        var me = this,
+            context = me.getEditingContext(record, columnHeader),
+            value, ed;
+
+        
+        
+        
+        me.completeEdit();
+
+        
+        if (!context || !me.grid.view.isVisible(true)) {
+            return false;
+        }
+
+        record = context.record;
+        columnHeader = context.column;
+
+        
+        if (columnHeader && !columnHeader.getEditor(record)) {
+            return false;
+        }
+
+        value = record.get(columnHeader.dataIndex);
+        context.originalValue = context.value = value;
+        if (me.beforeEdit(context) === false || me.fireEvent('beforeedit', me, context) === false || context.cancel) {
+            return false;
+        }
+
+        ed = me.getEditor(record, columnHeader);
+
+        
+        me.grid.view.cancelFocus();
+        me.view.focusCell({
+            row: context.rowIdx,
+            column: context.colIdx
+        });
+        if (ed) {
+            me.editTask.delay(15, me.showEditor, me, [ed, context, value]);
+            return true;
+        }
+        return false;
+    },
+
+    showEditor: function(ed, context, value) {
+        var me = this,
+            record = context.record,
+            columnHeader = context.column,
+            sm = me.grid.getSelectionModel(),
+            selection = sm.getCurrentPosition();
+
+        me.context = context;
+        me.setActiveEditor(ed);
+        me.setActiveRecord(record);
+        me.setActiveColumn(columnHeader);
+
+        
+        if (sm.selectByPosition && (!selection || selection.column !== context.colIdx || selection.row !== context.rowIdx)) {
+            sm.selectByPosition({
+                row: context.rowIdx,
+                column: context.colIdx
+            });
+        }
+
+        ed.startEdit(me.getCell(record, columnHeader), value);
+        me.editing = true;
+        me.scroll = me.view.el.getScroll();
+    },
+
+    completeEdit: function() {
+        var activeEd = this.getActiveEditor();
+        if (activeEd) {
+            activeEd.completeEdit();
+            this.editing = false;
+        }
+    },
+
+    
+    setActiveEditor: function(ed) {
+        this.activeEditor = ed;
+    },
+
+    getActiveEditor: function() {
+        return this.activeEditor;
+    },
+
+    setActiveColumn: function(column) {
+        this.activeColumn = column;
+    },
+
+    getActiveColumn: function() {
+        return this.activeColumn;
+    },
+
+    setActiveRecord: function(record) {
+        this.activeRecord = record;
+    },
+
+    getActiveRecord: function() {
+        return this.activeRecord;
+    },
+
+    getEditor: function(record, column) {
+        var me = this,
+            editors = me.editors,
+            editorId = column.getItemId(),
+            editor = editors.getByKey(editorId);
+
+        if (editor) {
+            return editor;
+        } else {
+            editor = column.getEditor(record);
+            if (!editor) {
+                return false;
+            }
+
+            
+            
+            
+            if (!(editor instanceof Ext.grid.CellEditor)) {
+                editor = new Ext.grid.CellEditor({
+                    editorId: editorId,
+                    field: editor,
+                    ownerCt: me.grid
+                });
+            } else {
+                editor.ownerCt = me.grid;
+            }
+            editor.editingPlugin = me;
+            editor.isForTree = me.grid.isTree;
+            editor.on({
+                scope: me,
+                specialkey: me.onSpecialKey,
+                complete: me.onEditComplete,
+                canceledit: me.cancelEdit
+            });
+            editors.add(editor);
+            return editor;
+        }
+    },
+    
+    
+    setColumnField: function(column, field) {
+        var ed = this.editors.getByKey(column.getItemId());
+        Ext.destroy(ed, column.field);
+        this.editors.removeAtKey(column.getItemId());
+        this.callParent(arguments);
+    },
+
+    
+    getCell: function(record, column) {
+        return this.grid.getView().getCell(record, column);
+    },
+
+    onSpecialKey: function(ed, field, e) {
+        var me = this,
+            grid = me.grid,
+            sm;
+            
+        if (e.getKey() === e.TAB) {
+            e.stopEvent();
+            
+            if (ed) {
+                
+                
+                ed.onEditorTab(e);
+            }
+            
+            sm = grid.getSelectionModel();
+            if (sm.onEditorTab) {
+                sm.onEditorTab(me, e);
+            }
+        }
+    },
+
+    onEditComplete : function(ed, value, startValue) {
+        var me = this,
+            grid = me.grid,
+            activeColumn = me.getActiveColumn(),
+            sm = grid.getSelectionModel(),
+            record;
+
+        if (activeColumn) {
+            record = me.context.record;
+
+            me.setActiveEditor(null);
+            me.setActiveColumn(null);
+            me.setActiveRecord(null);
+    
+            if (!me.validateEdit()) {
+                return;
+            }
+
+            
+            
+            if (!record.isEqual(value, startValue)) {
+                record.set(activeColumn.dataIndex, value);
+            }
+
+            
+            if (sm.setCurrentPosition) {
+                sm.setCurrentPosition(sm.getCurrentPosition());
+            }
+            grid.getView().getEl(activeColumn).focus();
+
+            me.context.value = value;
+            me.fireEvent('edit', me, me.context);
+        }
+    },
+
+    
+    cancelEdit: function() {
+        var me = this,
+            activeEd = me.getActiveEditor(),
+            viewEl = me.grid.getView().getEl(me.getActiveColumn());
+
+        me.setActiveEditor(null);
+        me.setActiveColumn(null);
+        me.setActiveRecord(null);
+        if (activeEd) {
+            activeEd.cancelEdit();
+            viewEl.focus();
+            me.callParent(arguments);
+        }
+    },
+
+    
+    startEditByPosition: function(position) {
+
+        
+        position.column = this.view.getHeaderCt().getVisibleHeaderClosestToIndex(position.column).getIndex();
+
+        return this.startEdit(position.row, position.column);
+    }
+});
+
+
+Ext.define('Ext.grid.plugin.DragDrop', {
+    extend: 'Ext.AbstractPlugin',
+    alias: 'plugin.gridviewdragdrop',
+
+    uses: [
+        'Ext.view.DragZone',
+        'Ext.grid.ViewDropZone'
+    ],
+
+    
+
+    
+    
+    
+    dragText : '{0} selected row{1}',
+    
+
+    
+    ddGroup : "GridDD",
+
+    
+
+    
+
+    
+    enableDrop: true,
+
+    
+    enableDrag: true,
+
+    init : function(view) {
+        view.on('render', this.onViewRender, this, {single: true});
+    },
+
+    
+    destroy: function() {
+        Ext.destroy(this.dragZone, this.dropZone);
+    },
+
+    enable: function() {
+        var me = this;
+        if (me.dragZone) {
+            me.dragZone.unlock();
+        }
+        if (me.dropZone) {
+            me.dropZone.unlock();
+        }
+        me.callParent();
+    },
+
+    disable: function() {
+        var me = this;
+        if (me.dragZone) {
+            me.dragZone.lock();
+        }
+        if (me.dropZone) {
+            me.dropZone.lock();
+        }
+        me.callParent();
+    },
+
+    onViewRender : function(view) {
+        var me = this;
+
+        if (me.enableDrag) {
+            me.dragZone = new Ext.view.DragZone({
+                view: view,
+                ddGroup: me.dragGroup || me.ddGroup,
+                dragText: me.dragText
+            });
+        }
+
+        if (me.enableDrop) {
+            me.dropZone = new Ext.grid.ViewDropZone({
+                view: view,
+                ddGroup: me.dropGroup || me.ddGroup
+            });
+        }
+    }
+});
+
+
+Ext.define('Ext.grid.plugin.RowEditing', {
+    extend: 'Ext.grid.plugin.Editing',
+    alias: 'plugin.rowediting',
+
+    requires: [
+        'Ext.grid.RowEditor'
+    ],
+
+    editStyle: 'row',
+
+    
+    autoCancel: true,
+
+    
+
+    
+    errorSummary: true,
+
+    constructor: function() {
+        var me = this;
+
+        me.callParent(arguments);
+
+        if (!me.clicksToMoveEditor) {
+            me.clicksToMoveEditor = me.clicksToEdit;
+        }
+
+        me.autoCancel = !!me.autoCancel;
+    },
+
+    init: function(grid) {
+        this.callParent([grid]);
+    },
+
+    
+    destroy: function() {
+        var me = this;
+        Ext.destroy(me.editor);
+        me.callParent(arguments);
+    },
+
+    
+    startEdit: function(record, columnHeader) {
+        var me = this,
+            editor = me.getEditor();
+
+        if ((editor.beforeEdit() !== false) && (me.callParent(arguments) !== false)) {
+            editor.startEdit(me.context.record, me.context.column);
+            return true;
+        }
+        return false;
+    },
+
+    
+    cancelEdit: function() {
+        var me = this;
+
+        if (me.editing) {
+            me.getEditor().cancelEdit();
+            me.callParent(arguments);
+        }
+    },
+
+    
+    completeEdit: function() {
+        var me = this;
+
+        if (me.editing && me.validateEdit()) {
+            me.editing = false;
+            me.fireEvent('edit', me, me.context);
+        }
+    },
+
+    
+    validateEdit: function() {
+        var me             = this,
+            editor         = me.editor,
+            context        = me.context,
+            record         = context.record,
+            newValues      = {},
+            originalValues = {},
+            editors        = editor.items.items,
+            e,
+            eLen           = editors.length,
+            name, item;
+
+        for (e = 0; e < eLen; e++) {
+            item = editors[e];
+            name = item.name;
+
+            newValues[name]      = item.getValue();
+            originalValues[name] = record.get(name);
+        }
+
+        Ext.apply(context, {
+            newValues      : newValues,
+            originalValues : originalValues
+        });
+
+        return me.callParent(arguments) && me.getEditor().completeEdit();
+    },
+
+    
+    getEditor: function() {
+        var me = this;
+
+        if (!me.editor) {
+            me.editor = me.initEditor();
+        }
+        return me.editor;
+    },
+
+    
+    initEditor: function() {
+        var me       = this,
+            grid     = me.grid,
+            view     = me.view,
+            headerCt = grid.headerCt,
+            btns     = ['saveBtnText', 'cancelBtnText', 'errorsText', 'dirtyText'],
+            b,
+            bLen     = btns.length,
+            cfg      = {
+                autoCancel: me.autoCancel,
+                errorSummary: me.errorSummary,
+                fields: headerCt.getGridColumns(),
+                hidden: true,
+                view: view,
+                
+                editingPlugin: me,
+                renderTo: view.el
+            },
+            item;
+
+        for (b = 0; b < bLen; b++) {
+            item = btns[b];
+
+            if (Ext.isDefined(me[item])) {
+                cfg[item] = me[item];
+            }
+        }
+
+        return Ext.create('Ext.grid.RowEditor', cfg);
+    },
+
+    
+    initEditTriggers: function() {
+        var me = this,
+            view = me.view,
+            moveEditorEvent = me.clicksToMoveEditor === 1 ? 'click' : 'dblclick';
+
+        me.callParent(arguments);
+
+        if (me.clicksToMoveEditor !== me.clicksToEdit) {
+            me.mon(view, 'cell' + moveEditorEvent, me.moveEditorByClick, me);
+        }
+
+        view.on({
+            render: function() {
+                me.mon(me.grid.headerCt, {
+                    scope: me,
+                    columnresize: me.onColumnResize,
+                    columnhide: me.onColumnHide,
+                    columnshow: me.onColumnShow,
+                    columnmove: me.onColumnMove
+                });
+            },
+            single: true
+        });
+    },
+
+    startEditByClick: function() {
+        var me = this;
+        if (!me.editing || me.clicksToMoveEditor === me.clicksToEdit) {
+            me.callParent(arguments);
+        }
+    },
+
+    moveEditorByClick: function() {
+        var me = this;
+        if (me.editing) {
+            me.superclass.onCellClick.apply(me, arguments);
+        }
+    },
+    
+    
+    onColumnAdd: function(ct, column) {
+        if (column.isHeader) {
+            var me = this,
+                editor;
+
+            me.initFieldAccessors(column);
+
+            
+            
+            editor = me.editor;
+            if (editor && editor.onColumnAdd) {
+                editor.onColumnAdd(column);
+            }
+        }
+    },
+
+    
+    onColumnRemove: function(ct, column) {
+        if (column.isHeader) {
+            var me = this,
+                editor = me.getEditor();
+
+            if (editor && editor.onColumnRemove) {
+                editor.onColumnRemove(column);
+            }
+            me.removeFieldAccessors(column);
+        }
+    },
+
+    
+    onColumnResize: function(ct, column, width) {
+        if (column.isHeader) {
+            var me = this,
+                editor = me.getEditor();
+
+            if (editor && editor.onColumnResize) {
+                editor.onColumnResize(column, width);
+            }
+        }
+    },
+
+    
+    onColumnHide: function(ct, column) {
+        
+        var me = this,
+            editor = me.getEditor();
+
+        if (editor && editor.onColumnHide) {
+            editor.onColumnHide(column);
+        }
+    },
+
+    
+    onColumnShow: function(ct, column) {
+        
+        var me = this,
+            editor = me.getEditor();
+
+        if (editor && editor.onColumnShow) {
+            editor.onColumnShow(column);
+        }
+    },
+
+    
+    onColumnMove: function(ct, column, fromIdx, toIdx) {
+        
+        var me = this,
+            editor = me.getEditor();
+
+        if (editor && editor.onColumnMove) {
+            
+            
+            editor.onColumnMove(column, fromIdx, toIdx - (toIdx > fromIdx ? 1 : 0));
+        }
+    },
+
+    
+    setColumnField: function(column, field) {
+        var me = this,
+            editor = me.getEditor();
+            
+        editor.removeField(column);
+        me.callParent(arguments);
+        me.getEditor().setField(column);
+    }
+});
+
+
+Ext.define('Ext.grid.property.Grid', {
+
+    extend: 'Ext.grid.Panel',
+
+    alias: 'widget.propertygrid',
+
+    alternateClassName: 'Ext.grid.PropertyGrid',
+
+    uses: [
+       'Ext.grid.plugin.CellEditing',
+       'Ext.grid.property.Store',
+       'Ext.grid.property.HeaderContainer',
+       'Ext.XTemplate',
+       'Ext.grid.CellEditor',
+       'Ext.form.field.Date',
+       'Ext.form.field.Text',
+       'Ext.form.field.Number',
+       'Ext.form.field.ComboBox'
+    ],
+
+   
+
+    
+
+    
+
+    
+
+    
+    valueField: 'value',
+
+    
+    nameField: 'name',
+
+    
+
+    
+    enableColumnMove: false,
+    columnLines: true,
+    stripeRows: false,
+    trackMouseOver: false,
+    clicksToEdit: 1,
+    enableHdMenu: false,
+
+    
+    initComponent : function(){
+        var me = this;
+
+        me.addCls(Ext.baseCSSPrefix + 'property-grid');
+        me.plugins = me.plugins || [];
+
+        
+        me.plugins.push(new Ext.grid.plugin.CellEditing({
+            clicksToEdit: me.clicksToEdit,
+
+            
+            startEdit: function(record, column) {
+                
+                return this.self.prototype.startEdit.call(this, record, me.headerCt.child('#' + me.valueField));
+            }
+        }));
+
+        me.selModel = {
+            selType: 'cellmodel',
+            onCellSelect: function(position) {
+                if (position.column != 1) {
+                    position.column = 1;
+                }
+                return this.self.prototype.onCellSelect.call(this, position);
+            }
+        };
+        me.customRenderers = me.customRenderers || {};
+        me.customEditors = me.customEditors || {};
+
+        
+        if (!me.store) {
+            me.propStore = me.store = new Ext.grid.property.Store(me, me.source);
+        }
+
+        if (me.sortableColumns) {
+            me.store.sort('name', 'ASC');
+        }
+        me.columns = new Ext.grid.property.HeaderContainer(me, me.store);
+
+        me.addEvents(
+            
+            'beforepropertychange',
+            
+            'propertychange'
+        );
+        me.callParent();
+
+        
+        me.getView().walkCells = this.walkCells;
+
+        
+        me.editors = {
+            'date'    : new Ext.grid.CellEditor({ field: new Ext.form.field.Date({selectOnFocus: true})}),
+            'string'  : new Ext.grid.CellEditor({ field: new Ext.form.field.Text({selectOnFocus: true})}),
+            'number'  : new Ext.grid.CellEditor({ field: new Ext.form.field.Number({selectOnFocus: true})}),
+            'boolean' : new Ext.grid.CellEditor({ field: new Ext.form.field.ComboBox({
+                editable: false,
+                store: [[ true, me.headerCt.trueText ], [false, me.headerCt.falseText ]]
+            })})
+        };
+
+        
+        me.store.on('update', me.onUpdate, me);
+    },
+
+    
+    onUpdate : function(store, record, operation) {
+        var me = this,
+            v, oldValue;
+
+        if (me.rendered && operation == Ext.data.Model.EDIT) {
+            v = record.get(me.valueField);
+            oldValue = record.modified.value;
+            if (me.fireEvent('beforepropertychange', me.source, record.getId(), v, oldValue) !== false) {
+                if (me.source) {
+                    me.source[record.getId()] = v;
+                }
+                record.commit();
+                me.fireEvent('propertychange', me.source, record.getId(), v, oldValue);
+            } else {
+                record.reject();
+            }
+        }
+    },
+
+    
+    walkCells: function(pos, direction, e, preventWrap, verifierFn, scope) {
+        if (direction == 'left') {
+            direction = 'up';
+        } else if (direction == 'right') {
+            direction = 'down';
+        }
+        pos = Ext.view.Table.prototype.walkCells.call(this, pos, direction, e, preventWrap, verifierFn, scope);
+        if (!pos.column) {
+            pos.column = 1;
+        }
+        return pos;
+    },
+
+    
+    
+    getCellEditor : function(record, column) {
+        var me = this,
+            propName = record.get(me.nameField),
+            val = record.get(me.valueField),
+            editor = me.customEditors[propName];
+
+        
+        
+        if (editor) {
+            if (!(editor instanceof Ext.grid.CellEditor)) {
+                if (!(editor instanceof Ext.form.field.Base)) {
+                    editor = Ext.ComponentManager.create(editor, 'textfield');
+                }
+                editor = me.customEditors[propName] = new Ext.grid.CellEditor({ field: editor });
+            }
+        } else if (Ext.isDate(val)) {
+            editor = me.editors.date;
+        } else if (Ext.isNumber(val)) {
+            editor = me.editors.number;
+        } else if (Ext.isBoolean(val)) {
+            editor = me.editors['boolean'];
+        } else {
+            editor = me.editors.string;
+        }
+
+        
+        editor.editorId = propName;
+        return editor;
+    },
+
+    beforeDestroy: function() {
+        var me = this;
+        me.callParent();
+        me.destroyEditors(me.editors);
+        me.destroyEditors(me.customEditors);
+        delete me.source;
+    },
+
+    destroyEditors: function (editors) {
+        for (var ed in editors) {
+            if (editors.hasOwnProperty(ed)) {
+                Ext.destroy(editors[ed]);
+            }
+        }
+    },
+
+    
+    setSource: function(source) {
+        this.source = source;
+        this.propStore.setSource(source);
+    },
+
+    
+    getSource: function() {
+        return this.propStore.getSource();
+    },
+
+    
+    setProperty: function(prop, value, create) {
+        this.propStore.setValue(prop, value, create);
+    },
+
+    
+    removeProperty: function(prop) {
+        this.propStore.remove(prop);
+    }
+
+    
+    
+});
+
+
+Ext.define('Ext.grid.property.HeaderContainer', {
+
+    extend: 'Ext.grid.header.Container',
+
+    alternateClassName: 'Ext.grid.PropertyColumnModel',
+    
+    nameWidth: 115,
+
+    
+    
+    nameText : 'Name',
+    
+    
+    valueText : 'Value',
+    
+    
+    dateFormat : 'm/j/Y',
+    
+    
+    trueText: 'true',
+    
+    
+    falseText: 'false',
+    
+
+    
+    nameColumnCls: Ext.baseCSSPrefix + 'grid-property-name',
+
+    
+    constructor : function(grid, store) {
+        var me = this;
+        
+        me.grid = grid;
+        me.store = store;
+        me.callParent([{
+            items: [{
+                header: me.nameText,
+                width: grid.nameColumnWidth || me.nameWidth,
+                sortable: grid.sortableColumns,
+                dataIndex: grid.nameField,
+                renderer: Ext.Function.bind(me.renderProp, me),
+                itemId: grid.nameField,
+                menuDisabled :true,
+                tdCls: me.nameColumnCls
+            }, {
+                header: me.valueText,
+                renderer: Ext.Function.bind(me.renderCell, me),
+                getEditor: Ext.Function.bind(me.getCellEditor, me),
+                sortable: grid.sortableColumns,
+                flex: 1,
+                fixed: true,
+                dataIndex: grid.valueField,
+                itemId: grid.valueField,
+                menuDisabled: true
+            }]
+        }]);
+    },
+    
+    getCellEditor: function(record){
+        return this.grid.getCellEditor(record, this);
+    },
+
+    
+    
+    renderProp : function(v) {
+        return this.getPropertyName(v);
+    },
+
+    
+    
+    renderCell : function(val, meta, rec) {
+        var me = this,
+            renderer = me.grid.customRenderers[rec.get(me.grid.nameField)],
+            result = val;
+
+        if (renderer) {
+            return renderer.apply(me, arguments);
+        }
+        if (Ext.isDate(val)) {
+            result = me.renderDate(val);
+        } else if (Ext.isBoolean(val)) {
+            result = me.renderBool(val);
+        }
+        return Ext.util.Format.htmlEncode(result);
+    },
+
+    
+    renderDate : Ext.util.Format.date,
+
+    
+    renderBool : function(bVal) {
+        return this[bVal ? 'trueText' : 'falseText'];
+    },
+
+    
+    
+    getPropertyName : function(name) {
+        var pn = this.grid.propertyNames;
+        return pn && pn[name] ? pn[name] : name;
+    }
+});
+
+
+Ext.define('Ext.grid.property.Property', {
+    extend: 'Ext.data.Model',
+
+    alternateClassName: 'Ext.PropGridProperty',
+
+    fields: [{
+        name: 'name',
+        type: 'string'
+    }, {
+        name: 'value'
+    }],
+    idProperty: 'name'
+});
+
+
+Ext.define('Ext.grid.property.Store', {
+
+    extend: 'Ext.data.Store',
+
+    alternateClassName: 'Ext.grid.PropertyStore',
+
+    sortOnLoad: false,
+
+    uses: ['Ext.data.reader.Reader', 'Ext.data.proxy.Proxy', 'Ext.data.ResultSet', 'Ext.grid.property.Property'],
+
+    
+    constructor : function(grid, source){
+        var me = this;
+        
+        me.grid = grid;
+        me.source = source;
+        me.callParent([{
+            data: source,
+            model: Ext.grid.property.Property,
+            proxy: me.getProxy()
+        }]);
+    },
+
+    
+    getProxy: function() {
+        if (!this.proxy) {
+            Ext.grid.property.Store.prototype.proxy = new Ext.data.proxy.Memory({
+                model: Ext.grid.property.Property,
+                reader: this.getReader()
+            });
+        }
+        return this.proxy;
+    },
+
+    
+    getReader: function() {
+        if (!this.reader) {
+            Ext.grid.property.Store.prototype.reader = new Ext.data.reader.Reader({
+                model: Ext.grid.property.Property,
+
+                buildExtractors: Ext.emptyFn,
+
+                read: function(dataObject) {
+                    return this.readRecords(dataObject);
+                },
+
+                readRecords: function(dataObject) {
+                    var val,
+                        propName,
+                        result = {
+                            records: [],
+                            success: true
+                        };
+
+                    for (propName in dataObject) {
+                        if (dataObject.hasOwnProperty(propName)) {
+                            val = dataObject[propName];
+                            if (this.isEditableValue(val)) {
+                                result.records.push(new Ext.grid.property.Property({
+                                    name: propName,
+                                    value: val
+                                }, propName));
+                            }
+                        }
+                    }
+                    result.total = result.count = result.records.length;
+                    return new Ext.data.ResultSet(result);
+                },
+
+                
+                isEditableValue: function(val){
+                    return Ext.isPrimitive(val) || Ext.isDate(val);
+                }
+            });
+        }
+        return this.reader;
+    },
+
+    
+    setSource : function(dataObject) {
+        var me = this;
+
+        me.source = dataObject;
+        me.suspendEvents();
+        me.removeAll();
+        me.proxy.data = dataObject;
+        me.load();
+        me.resumeEvents();
+        me.fireEvent('datachanged', me);
+        me.fireEvent('refresh', me);
+    },
+
+    
+    getProperty : function(row) {
+       return Ext.isNumber(row) ? this.getAt(row) : this.getById(row);
+    },
+
+    
+    setValue : function(prop, value, create){
+        var me = this,
+            rec = me.getRec(prop);
+            
+        if (rec) {
+            rec.set('value', value);
+            me.source[prop] = value;
+        } else if (create) {
+            
+            me.source[prop] = value;
+            rec = new Ext.grid.property.Property({name: prop, value: value}, prop);
+            me.add(rec);
+        }
+    },
+
+    
+    remove : function(prop) {
+        var rec = this.getRec(prop);
+        if (rec) {
+            this.callParent([rec]);
+            delete this.source[prop];
+        }
+    },
+
+    
+    getRec : function(prop) {
+        return this.getById(prop);
+    },
+
+    
+    getSource : function() {
+        return this.source;
+    }
+});
+
+
+Ext.define('Ext.layout.ClassList', (function () {
+
+    var splitWords = Ext.String.splitWords,
+        toMap = Ext.Array.toMap;
+
+    return {
+        dirty: false,
+
+        constructor: function (owner) {
+            this.owner = owner;
+            this.map = toMap(this.classes = splitWords(owner.el.className));
+        },
+
+        
+        add: function (cls) {
+            var me = this;
+
+            if (!me.map[cls]) {
+                me.map[cls] = true;
+                me.classes.push(cls);
+                if (!me.dirty) {
+                    me.dirty = true;
+                    me.owner.markDirty();
+                }
+            }
+        },
+
+        
+        addMany: function (classes) {
+            Ext.each(splitWords(classes), this.add, this);
+        },
+
+        contains: function (cls) {
+            return this.map[cls];
+        },
+
+        flush: function () {
+            this.owner.el.className = this.classes.join(' ');
+            this.dirty = false;
+        },
+
+        
+        remove: function (cls) {
+            var me = this;
+
+            if (me.map[cls]) {
+                delete me.map[cls];
+                me.classes = Ext.Array.filter(me.classes, function (c) {
+                    return c != cls;
+                });
+                if (!me.dirty) {
+                    me.dirty = true;
+                    me.owner.markDirty();
+                }
+            }
+        },
+
+        
+        removeMany: function (classes) {
+            var me = this,
+                remove = toMap(splitWords(classes));
+
+            me.classes = Ext.Array.filter(me.classes, function (c) {
+                if (!remove[c]) {
+                    return true;
+                }
+
+                delete me.map[c];
+                if (!me.dirty) {
+                    me.dirty = true;
+                    me.owner.markDirty();
+                }
+                return false;
+            });
+        }
+    };
+}()));
+
+
+Ext.define('Ext.util.Queue', {
+
+    constructor: function() {
+        this.clear();
+    },
+
+    add : function(obj) {
+        var me = this,
+            key = me.getKey(obj);
+
+        if (!me.map[key]) {
+            ++me.length;
+            me.items.push(obj);
+            me.map[key] = obj;
+        }
+
+        return obj;
+    },
+
+    
+    clear : function(){
+        var me = this,
+            items = me.items;
+
+        me.items = [];
+        me.map = {};
+        me.length = 0;
+
+        return items;
+    },
+
+    contains: function (obj) {
+        var key = this.getKey(obj);
+
+        return this.map.hasOwnProperty(key);
+    },
+
+    
+    getCount : function(){
+        return this.length;
+    },
+
+    getKey : function(obj){
+         return obj.id;
+    },
+
+    
+    remove : function(obj){
+        var me = this,
+            key = me.getKey(obj),
+            items = me.items,
+            index;
+
+        if (me.map[key]) {
+            index = Ext.Array.indexOf(items, obj);
+            Ext.Array.erase(items, index, 1);
+            delete me.map[key];
+            --me.length;
+        }
+
+        return obj;
+    }
+});
+
+
+Ext.define('Ext.layout.ContextItem', {
+    
+    requires: ['Ext.layout.ClassList'],
+
+    heightModel: null,
+    widthModel: null,
+    sizeModel: null,
+
+    boxChildren: null,
+
+    boxParent: null,
+
+    children: [],
+
+    dirty: null,
+
+    
+    dirtyCount: 0,
+
+    hasRawContent: true,
+
+    isContextItem: true,
+
+    isTopLevel: false,
+
+    consumersContentHeight: 0,
+    consumersContentWidth: 0,
+    consumersContainerHeight: 0,
+    consumersContainerWidth: 0,
+    consumersHeight: 0,
+    consumersWidth: 0,
+
+    ownerCtContext: null,
+
+    remainingChildLayouts: 0,
+    remainingComponentChildLayouts: 0,
+    remainingContainerChildLayouts: 0,
+
+    
+    props: null,
+
+    
+    state: null,
+
+    
+    wrapsComponent: false,
+
+    constructor: function (config) {
+        var me = this,
+            el, ownerCt, ownerCtContext, sizeModel, target;
+
+        Ext.apply(me, config);
+
+        el = me.el;
+        me.id = el.id;
+        me.lastBox = el.lastBox;
+
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+
+        me.flushedProps = {};
+        me.props = {};
+
+        
+        me.styles = {};
+
+        target = me.target;
+        if (target.isComponent) {
+            me.wrapsComponent = true;
+
+            
+            
+            ownerCt = target.ownerCt;
+            if (ownerCt && (ownerCtContext = me.context.items[ownerCt.el.id])) {
+                me.ownerCtContext = ownerCtContext;
+            }
+
+            
+            
+            me.sizeModel = sizeModel = target.getSizeModel(ownerCtContext &&
+                ownerCtContext.widthModel.pairsByHeightOrdinal[ownerCtContext.heightModel.ordinal]);
+
+            me.widthModel = sizeModel.width;
+            me.heightModel = sizeModel.height;
+
+            
+            
+            
+            
+            
+        }
+    },
+
+    
+    init: function (full, options) {
+        var me = this,
+            oldProps = me.props,
+            oldDirty = me.dirty,
+            ownerCtContext = me.ownerCtContext,
+            ownerLayout = me.target.ownerLayout,
+            firstTime = !me.state,
+            ret = full || firstTime,
+            children, i, n, ownerCt, sizeModel, target,
+            oldHeightModel = me.heightModel,
+            oldWidthModel = me.widthModel,
+            newHeightModel, newWidthModel;
+
+        me.dirty = me.invalid = false;
+        me.props = {};
+
+        if (me.boxChildren) {
+            me.boxChildren.length = 0; 
+        }
+
+        if (!firstTime) {
+            me.clearAllBlocks('blocks');
+            me.clearAllBlocks('domBlocks');
+        }
+
+        
+        if (!me.wrapsComponent) {
+            return ret;
+        }
+
+        
+        target = me.target;
+        me.state = {}; 
+
+        if (firstTime) {
+            
+            
+            if (target.beforeLayout) {
+                target.beforeLayout();
+            }
+
+            
+            
+            
+            
+            
+            
+            if (!ownerCtContext && (ownerCt = target.ownerCt)) {
+                ownerCtContext = me.context.items[ownerCt.el.id];
+            }
+
+            if (ownerCtContext) {
+                me.ownerCtContext = ownerCtContext;
+                me.isBoxParent = target.ownerLayout.isItemBoxParent(me);
+            } else {
+                me.isTopLevel = true; 
+            }
+
+            me.frameBodyContext = me.getEl('frameBody');
+        } else {
+            ownerCtContext = me.ownerCtContext;
+
+            
+            me.isTopLevel = !ownerCtContext;
+
+            
+            
+            children = me.children;
+            for (i = 0, n = children.length; i < n; ++i) {
+                children[i].init(true);
+            }
+        }
+
+        
+        
+        
+        me.hasRawContent = !(target.isContainer && target.items.items.length > 0);
+
+        if (full) {
+            
+            
+            me.widthModel = me.heightModel = null;
+            sizeModel = target.getSizeModel(ownerCtContext && 
+                ownerCtContext.widthModel.pairsByHeightOrdinal[ownerCtContext.heightModel.ordinal]);
+
+            if (firstTime) {
+                me.sizeModel = sizeModel;
+            }
+
+            me.widthModel = sizeModel.width;
+            me.heightModel = sizeModel.height;
+        } else if (oldProps) {
+            
+            
+            me.recoverProp('x', oldProps, oldDirty);
+            me.recoverProp('y', oldProps, oldDirty);
+
+            
+            if (me.widthModel.calculated) {
+                me.recoverProp('width', oldProps, oldDirty);
+            }
+            if (me.heightModel.calculated) {
+                me.recoverProp('height', oldProps, oldDirty);
+            }
+        }
+
+        if (oldProps && ownerLayout && ownerLayout.manageMargins) {
+            me.recoverProp('margin-top', oldProps, oldDirty);
+            me.recoverProp('margin-right', oldProps, oldDirty);
+            me.recoverProp('margin-bottom', oldProps, oldDirty);
+            me.recoverProp('margin-left', oldProps, oldDirty);
+        }
+
+        
+        
+        if (options) {
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            
+            newHeightModel = options.heightModel;
+            newWidthModel = options.widthModel;
+            if (newWidthModel && newHeightModel && oldWidthModel && oldHeightModel) {
+                if (oldWidthModel.shrinkWrap && oldHeightModel.shrinkWrap) {
+                    if (newWidthModel.constrainedMax && newHeightModel.constrainedMin) {
+                        newHeightModel = null;
+                    }
+                }
+            }
+
+            
+            if (newWidthModel) {
+                me.widthModel = newWidthModel;
+            }
+            if (newHeightModel) {
+                me.heightModel = newHeightModel;
+            }
+
+            if (options.state) {
+                Ext.apply(me.state, options.state);
+            }
+        }
+
+        return ret;
+    },
+
+    
+    initContinue: function (full) {
+        var me = this,
+            ownerCtContext = me.ownerCtContext,
+            widthModel = me.widthModel,
+            boxParent;
+
+        if (full) {
+            if (ownerCtContext && widthModel.shrinkWrap) {
+                boxParent = ownerCtContext.isBoxParent ? ownerCtContext : ownerCtContext.boxParent;
+                if (boxParent) {
+                    boxParent.addBoxChild(me);
+                }
+            } else if (widthModel.natural) {
+                me.boxParent = ownerCtContext;
+            }
+        }
+
+        return full;
+    },
+
+    
+    initDone: function (full, componentChildrenDone, containerChildrenDone, containerLayoutDone) {
+        var me = this,
+            props = me.props,
+            state = me.state;
+
+        
+        if (componentChildrenDone) {
+            props.componentChildrenDone = true;
+        }
+        if (containerChildrenDone) {
+            props.containerChildrenDone = true;
+        }
+        if (containerLayoutDone) {
+            props.containerLayoutDone = true;
+        }
+
+        if (me.boxChildren && me.boxChildren.length && me.widthModel.shrinkWrap) {
+            
+            
+            me.el.setWidth(10000);
+
+            
+            state.blocks = (state.blocks || 0) + 1;
+        }
+    },
+
+    
+    initAnimation: function() {
+        var me = this,
+            target = me.target,
+            ownerCtContext = me.ownerCtContext;
+
+        if (ownerCtContext && ownerCtContext.isTopLevel) {
+            
+            
+            me.animatePolicy = target.ownerLayout.getAnimatePolicy(me);
+        } else if (!ownerCtContext && target.isCollapsingOrExpanding && target.animCollapse) {
+            
+            
+            
+            me.animatePolicy = target.componentLayout.getAnimatePolicy(me);
+        }
+
+        if (me.animatePolicy) {
+            me.context.queueAnimation(me);
+        }
+    },
+
+    noFraming: { left: 0, top: 0, right: 0, bottom: 0, width: 0, height: 0 },
+
+    
+    addCls: function(newCls) {
+        this.getClassList().addMany(newCls);
+    },
+
+    
+    removeCls: function(removeCls) {
+        this.getClassList().removeMany(removeCls);
+    },
+
+    
+    addBlock: function (name, layout, propName) {
+        var me = this,
+            collection = me[name] || (me[name] = {}),
+            blockedLayouts = collection[propName] || (collection[propName] = {});
+
+        if (!blockedLayouts[layout.id]) {
+            blockedLayouts[layout.id] = layout;
+            ++layout.blockCount;
+            ++me.context.blockCount;
+        }
+    },
+
+    addBoxChild: function (boxChildItem) {
+        var me = this,
+            children,
+            widthModel = boxChildItem.widthModel;
+
+        boxChildItem.boxParent = this;
+
+        
+        
+        
+        
+        
+        
+        boxChildItem.measuresBox = widthModel.shrinkWrap ? boxChildItem.hasRawContent : widthModel.natural;
+
+        if (boxChildItem.measuresBox) {
+            children = me.boxChildren;
+
+            if (children) {
+                children.push(boxChildItem);
+            } else {
+                me.boxChildren = [ boxChildItem ];
+            }
+        }
+    },
+
+    
+    addTrigger: function (propName, inDom) {
+        var me = this,
+            name = inDom ? 'domTriggers' : 'triggers',
+            collection = me[name] || (me[name] = {}),
+            context = me.context,
+            layout = context.currentLayout,
+            triggers = collection[propName] || (collection[propName] = {});
+
+        if (!triggers[layout.id]) {
+            triggers[layout.id] = layout;
+            ++layout.triggerCount;
+
+            triggers = context.triggers[inDom ? 'dom' : 'data'];
+            (triggers[layout.id] || (triggers[layout.id] = [])).push({
+                item: this,
+                prop: propName
+            });
+
+            if (me.props[propName] !== undefined) {
+                if (!inDom || !(me.dirty && (propName in me.dirty))) {
+                    ++layout.firedTriggers;
+                }
+            }
+        }
+    },
+
+    boxChildMeasured: function () {
+        var me = this,
+            state = me.state,
+            count = (state.boxesMeasured = (state.boxesMeasured || 0) + 1);
+
+        if (count == me.boxChildren.length) {
+            
+            
+            state.clearBoxWidth = 1;
+            ++me.context.progressCount;
+            me.markDirty();
+        }
+    },
+
+    borderNames: [ 'border-top-width', 'border-right-width', 'border-bottom-width', 'border-left-width'],
+    marginNames: [ 'margin-top', 'margin-right', 'margin-bottom', 'margin-left' ],
+    paddingNames: [ 'padding-top', 'padding-right', 'padding-bottom', 'padding-left' ],
+    trblNames: [ 'top', 'right', 'bottom', 'left' ],
+
+    cacheMissHandlers: {
+        borderInfo: function (me) {
+            var info = me.getStyles(me.borderNames, me.trblNames);
+
+            info.width = info.left + info.right;
+            info.height = info.top + info.bottom;
+
+            return info;
+        },
+
+        marginInfo: function (me) {
+            var info = me.getStyles(me.marginNames, me.trblNames);
+
+            info.width = info.left + info.right;
+            info.height = info.top + info.bottom;
+
+            return info;
+        },
+
+        paddingInfo: function (me) {
+            
+            var item = me.frameBodyContext || me,
+                info = item.getStyles(me.paddingNames, me.trblNames);
+
+            info.width = info.left + info.right;
+            info.height = info.top + info.bottom;
+
+            return info;
+        }
+    },
+
+    checkCache: function (entry) {
+        return this.cacheMissHandlers[entry](this);
+    },
+
+    clearAllBlocks: function (name) {
+        var collection = this[name],
+            propName;
+
+        if (collection) {
+            for (propName in collection) {
+                this.clearBlocks(name, propName);
+            }
+        }
+    },
+
+    
+    clearBlocks: function (name, propName) {
+        var collection = this[name],
+            blockedLayouts = collection && collection[propName],
+            context, layout, layoutId;
+
+        if (blockedLayouts) {
+            delete collection[propName];
+
+            context = this.context;
+
+            for (layoutId in blockedLayouts) {
+                layout = blockedLayouts[layoutId];
+
+                --context.blockCount;
+                if (! --layout.blockCount && !layout.pending && !layout.done) {
+                    context.queueLayout(layout);
+                }
+            }
+        }
+    },
+
+    
+    block: function (layout, propName) {
+        this.addBlock('blocks', layout, propName);
+    },
+
+    
+    domBlock: function (layout, propName) {
+        this.addBlock('domBlocks', layout, propName);
+    },
+
+    
+    fireTriggers: function (name, propName) {
+        var collection = this[name],
+            triggers = collection && collection[propName],
+            context = this.context,
+            layout, layoutId;
+
+        if (triggers) {
+            for (layoutId in triggers) {
+                layout = triggers[layoutId];
+                ++layout.firedTriggers;
+                if (!layout.done && !layout.blockCount && !layout.pending) {
+                    context.queueLayout(layout);
+                }
+            }
+        }
+    },
+
+    
+    flush: function () {
+        var me = this,
+            dirty = me.dirty,
+            state = me.state,
+            targetEl = me.el;
+
+        me.dirtyCount = 0;
+
+        
+        if (me.classList && me.classList.dirty) {
+            me.classList.flush();
+        }
+
+        
+        if ('attributes' in me) {
+            targetEl.set(me.attributes);
+            delete me.attributes;
+        }
+
+        
+        if ('innerHTML' in me) {
+            targetEl.innerHTML = me.innerHTML;
+            delete me.innerHTML;
+        }
+
+        if (state && state.clearBoxWidth) {
+            state.clearBoxWidth = 0;
+            me.el.setStyle('width', null);
+
+            if (! --state.blocks) {
+                me.context.queueItemLayouts(me);
+            }
+        }
+
+        if (dirty) {
+            delete me.dirty;
+            me.writeProps(dirty, true);
+        }
+    },
+
+    
+    flushAnimations: function() {
+        var me = this,
+            animateFrom = me.lastBox,
+            target, targetAnim, duration, animateProps, anim,
+            changeCount, j, propsLen, propName, oldValue, newValue;
+
+        
+        if (animateFrom) {
+            target = me.target;
+            targetAnim = target.layout && target.layout.animate;
+            if (targetAnim) {
+                duration = Ext.isNumber(targetAnim) ? targetAnim : targetAnim.duration;
+            }
+            animateProps = Ext.Object.getKeys(me.animatePolicy);
+
+            
+            
+            anim = Ext.apply({}, {
+                from: {},
+                to: {},
+                duration: duration || Ext.fx.Anim.prototype.duration
+            }, targetAnim);
+
+            for (changeCount = 0, j = 0, propsLen = animateProps.length; j < propsLen; j++) {
+                propName = animateProps[j];
+                oldValue = animateFrom[propName];
+                newValue = me.peek(propName);
+                if (oldValue != newValue) {
+                    propName = me.translateProps[propName]||propName;
+                    anim.from[propName] = oldValue;
+                    anim.to[propName] = newValue;
+                    ++changeCount;
+                }
+            }
+
+            
+            if (changeCount) {
+                
+                if (me.isCollapsingOrExpanding === 1) {
+                    target.componentLayout.undoLayout(me);
+                }
+
+                
+                else {
+                    me.writeProps(anim.from);
+                }
+                me.el.animate(anim);
+                
+                Ext.fx.Manager.getFxQueue(me.el.id)[0].on({
+                    afteranimate: function() {
+                        if (me.isCollapsingOrExpanding === 1) {
+                            target.componentLayout.redoLayout(me);
+                            target.afterCollapse(true);
+                        } else if (me.isCollapsingOrExpanding === 2) {
+                            target.afterExpand(true);
+                        }
+                    }
+                });
+            }
+        }
+    },
+
+    
+    getBorderInfo: function () {
+        var me = this,
+            info = me.borderInfo;
+
+        if (!info) {
+            me.borderInfo = info = me.checkCache('borderInfo');
+        }
+
+        return info;
+    },
+
+    
+    getClassList: function () {
+        return this.classList || (this.classList = new Ext.layout.ClassList(this));
+    },
+
+    
+    getEl: function (nameOrEl, owner) {
+        var me = this,
+            src, el, elContext;
+
+        if (nameOrEl) {
+            if (nameOrEl.dom) {
+                el = nameOrEl;
+            } else {
+                src = me.target;
+                if (owner) {
+                    src = owner;
+                }
+
+                el = src[nameOrEl];
+                if (typeof el == 'function') { 
+                    el = el.call(src);
+                    if (el === me.el) {
+                        return this; 
+                    }
+                }
+            }
+
+            if (el) {
+                elContext = me.context.getEl(me, el);
+            }
+        }
+
+        return elContext || null;
+    },
+
+    getFraming: function () {
+        var me = this;
+        if (!me.framingInfo) {
+            me.framingInfo = me.target.frameSize || me.noFraming;
+        }
+        return me.framingInfo;
+    },
+
+    
+    getFrameInfo: function () {
+        var me = this,
+            info = me.frameInfo,
+            frame, border;
+
+        if (!info) {
+            frame = me.getFraming();
+            border = me.getBorderInfo();
+            
+            me.frameInfo = info = {
+                top   : frame.top    + border.top,
+                right : frame.right  + border.right,
+                bottom: frame.bottom + border.bottom,
+                left  : frame.left   + border.left,
+                width : frame.width  + border.width,
+                height: frame.height + border.height
+            };
+        }
+
+        return info;
+    },
+
+    
+    getMarginInfo: function () {
+        var me = this,
+            info = me.marginInfo,
+            comp, manageMargins, margins, ownerLayout, ownerLayoutId;
+
+        if (!info) {
+            if (!me.wrapsComponent) {
+                info = me.checkCache('marginInfo');
+            } else {
+                comp = me.target;
+                ownerLayout = comp.ownerLayout;
+                ownerLayoutId = ownerLayout ? ownerLayout.id : null;
+                manageMargins = ownerLayout && ownerLayout.manageMargins;
+
+                
+                
+                
+                
+                
+                
+                
+                
+                
+
+                
+                
+                
+                
+
+                info = comp.margin$;
+                if (info && info.ownerId !== ownerLayoutId) {
+                    
+                    info = null;
+
+                    
+                    
+                    
+                }
+
+                if (!info) { 
+                    
+                    info = me.parseMargins(comp.margin) || me.checkCache('marginInfo');
+
+                    
+                    if (manageMargins) {
+                        margins = me.parseMargins(comp.margins, ownerLayout.defaultMargins);
+
+                        if (margins) { 
+                            
+                            info = {
+                                top:    info.top    + margins.top,
+                                right:  info.right  + margins.right,
+                                bottom: info.bottom + margins.bottom,
+                                left:   info.left   + margins.left
+                            };
+                        }
+
+                        me.setProp('margin-top', 0);
+                        me.setProp('margin-right', 0);
+                        me.setProp('margin-bottom', 0);
+                        me.setProp('margin-left', 0);
+                    }
+
+                    
+                    info.ownerId = ownerLayoutId;
+                    comp.margin$ = info;
+                }
+
+                info.width  = info.left + info.right;
+                info.height = info.top  + info.bottom;
+            }
+
+            me.marginInfo = info;
+        }
+
+        return info;
+    },
+
+    
+    clearMarginCache: function() {
+        delete this.marginInfo;
+        delete this.target.margin$;
+    },
+
+    
+    getPaddingInfo: function () {
+        var me = this,
+            info = me.paddingInfo;
+
+        if (!info) {
+            me.paddingInfo = info = me.checkCache('paddingInfo');
+        }
+
+        return info;
+    },
+
+    
+    getProp: function (propName) {
+        var me = this,
+            result = me.props[propName];
+
+        me.addTrigger(propName);
+        return result;
+    },
+
+    
+    getDomProp: function (propName) {
+        var me = this,
+            result = (me.dirty && (propName in me.dirty)) ? undefined : me.props[propName];
+
+        me.addTrigger(propName, true);
+        return result;
+    },
+
+    
+    getStyle: function (styleName) {
+        var me = this,
+            styles = me.styles,
+            info, value;
+
+        if (styleName in styles) {
+            value = styles[styleName];
+        } else {
+            info = me.styleInfo[styleName];
+            value = me.el.getStyle(styleName);
+
+            if (info && info.parseInt) {
+                value = parseInt(value, 10) || 0;
+            }
+
+            styles[styleName] = value;
+        }
+
+        return value;
+    },
+
+    
+    getStyles: function (styleNames, altNames) {
+        var me = this,
+            styleCache = me.styles,
+            values = {},
+            hits = 0,
+            n = styleNames.length,
+            i, missing, missingAltNames, name, info, styleInfo, styles, value;
+
+        altNames = altNames || styleNames;
+
+        
+        
+        for (i = 0; i < n; ++i) {
+            name = styleNames[i];
+
+            if (name in styleCache) {
+                values[altNames[i]] = styleCache[name];
+                ++hits;
+
+                if (i && hits==1) { 
+                    missing = styleNames.slice(0, i);
+                    missingAltNames = altNames.slice(0, i);
+                }
+            } else if (hits) {
+                (missing || (missing = [])).push(name);
+                (missingAltNames || (missingAltNames = [])).push(altNames[i]);
+            }
+        }
+
+        if (hits < n) {
+            missing = missing || styleNames;
+            missingAltNames = missingAltNames || altNames;
+            styleInfo = me.styleInfo;
+
+            styles = me.el.getStyle(missing);
+
+            for (i = missing.length; i--; ) {
+                name = missing[i];
+                info = styleInfo[name];
+                value = styles[name];
+
+                if (info && info.parseInt) {
+                    value = parseInt(value, 10) || 0;
+                }
+
+                values[missingAltNames[i]] = value;
+                styleCache[name] = value;
+            }
+        }
+
+        return values;
+    },
+
+    
+    hasProp: function (propName) {
+        var value = this.getProp(propName);
+        return typeof value != 'undefined';
+    },
+
+    
+    hasDomProp: function (propName) {
+        var value = this.getDomProp(propName);
+        return typeof value != 'undefined';
+    },
+
+    
+    invalidate: function (options) {
+        this.context.queueInvalidate(this, options);
+    },
+
+    markDirty: function () {
+        if (++this.dirtyCount == 1) {
+            
+            this.context.queueFlush(this);
+        }
+    },
+
+    onBoxMeasured: function () {
+        var boxParent = this.boxParent,
+            state = this.state;
+
+        if (boxParent && boxParent.widthModel.shrinkWrap && !state.boxMeasured && this.measuresBox) {
+            
+            
+            state.boxMeasured = 1; 
+            boxParent.boxChildMeasured();
+        }
+    },
+
+    parseMargins: function (margins, defaultMargins) {
+        if (margins === true) {
+            margins = 5;
+        }
+
+        var type = typeof margins,
+            ret;
+
+        if (type == 'string' || type == 'number') {
+            ret = Ext.util.Format.parseBox(margins);
+        } else if (margins || defaultMargins) {
+            ret = { top: 0, right: 0, bottom: 0, left: 0 }; 
+
+            if (defaultMargins) {
+                Ext.apply(ret, this.parseMargins(defaultMargins)); 
+            }
+
+            Ext.apply(ret, margins); 
+        }
+
+        return ret;
+    },
+
+    peek: function (propName) {
+        return this.props[propName];
+    },
+
+    
+    recoverProp: function (propName, oldProps, oldDirty) {
+        var me = this,
+            props = me.props,
+            dirty;
+
+        if (propName in oldProps) {
+            props[propName] = oldProps[propName];
+
+            if (oldDirty && propName in oldDirty) {
+                dirty = me.dirty || (me.dirty = {});
+                dirty[propName] = oldDirty[propName];
+            }
+        }
+    },
+
+    redo: function(deep) {
+        var me = this,
+            items, len, i;
+
+        me.revertProps(me.props);
+
+        if (deep && me.wrapsComponent) {
+            
+            if (me.childItems) {
+                for (i = 0, items = me.childItems, len = items.length; i < len; i++) {
+                    items[i].redo(deep);
+                }
+            }
+
+            
+            for (i = 0, items = me.children, len = items.length; i < len; i++) {
+                items[i].redo();
+            }
+        }
+    },
+
+    revertProps: function (props) {
+        var name,
+            flushed = this.flushedProps,
+            reverted = {};
+
+        for (name in props) {
+            if (flushed.hasOwnProperty(name)) {
+                reverted[name] = props[name];
+            }
+        }
+
+        this.writeProps(reverted);
+    },
+
+    
+    setAttribute: function(name, value) {
+        var me = this;
+        if (!me.attributes) {
+            me.attributes = {};
+        }
+        me.attributes[name] = value;
+        me.markDirty();
+    },
+
+    setBox: function (box) {
+        var me = this;
+
+        if ('left' in box) {
+            me.setProp('x', box.left);
+        }
+        if ('top' in box) {
+            me.setProp('y', box.top);
+        }
+
+        
+        
+        
+        me.setSize(box.width, box.height);
+    },
+
+    
+    setContentHeight: function (height, measured) {
+        if (!measured && this.hasRawContent) {
+            return 1;
+        }
+
+        return this.setProp('contentHeight', height);
+    },
+
+    
+    setContentWidth: function (width, measured) {
+        if (!measured && this.hasRawContent) {
+            return 1;
+        }
+
+        return this.setProp('contentWidth', width);
+    },
+
+    
+    setContentSize: function (width, height, measured) {
+        return this.setContentWidth(width, measured) +
+               this.setContentHeight(height, measured) == 2;
+    },
+
+    
+    setProp: function (propName, value, dirty) {
+        var me = this,
+            valueType = typeof value,
+            borderBox, info;
+
+        if (valueType == 'undefined' || (valueType === 'number' && isNaN(value))) {
+            return 0;
+        }
+        if (me.props[propName] === value) {
+            return 1;
+        }
+
+        me.props[propName] = value;
+        ++me.context.progressCount;
+
+        if (dirty === false) {
+            
+            
+            me.fireTriggers('domTriggers', propName);
+            me.clearBlocks('domBlocks', propName);
+        } else {
+            info = me.styleInfo[propName];
+            if (info) {
+                if (!me.dirty) {
+                    me.dirty = {};
+                }
+
+                if (propName == 'width' || propName == 'height') {
+                    borderBox = me.isBorderBoxValue;
+                    if (borderBox == null) {
+                        me.isBorderBoxValue = borderBox = !!me.el.isBorderBox();
+                    }
+
+                    if (!borderBox) {
+                        me.borderInfo || me.getBorderInfo();
+                        me.paddingInfo || me.getPaddingInfo();
+                    }
+                }
+                me.dirty[propName] = value;
+                me.markDirty();
+            }
+        }
+
+        
+        me.fireTriggers('triggers', propName);
+        me.clearBlocks('blocks', propName);
+        return 1;
+    },
+
+    
+    setHeight: function (height, dirty ) {
+        var me = this,
+            comp = me.target,
+            frameBody, frameInfo, padding;
+
+        if (height < 0) {
+            height = 0;
+        }
+        if (!me.wrapsComponent) {
+            if (!me.setProp('height', height, dirty)) {
+                return NaN;
+            }
+        } else {
+            height = Ext.Number.constrain(height, comp.minHeight || 0, comp.maxHeight);
+            if (!me.setProp('height', height, dirty)) {
+                return NaN;
+            }
+
+            frameBody = me.frameBodyContext;
+            if (frameBody){
+                frameInfo = me.getFrameInfo();
+                frameBody.setHeight(height - frameInfo.height, dirty);
+            }
+        }
+
+        return height;
+    },
+
+    
+    setWidth: function (width, dirty ) {
+        var me = this,
+            comp = me.target,
+            frameBody, frameInfo, padding;
+
+        if (width < 0) {
+            width = 0;
+        }
+        if (!me.wrapsComponent) {
+            if (!me.setProp('width', width, dirty)) {
+                return NaN;
+            }
+        } else {
+            width = Ext.Number.constrain(width, comp.minWidth || 0, comp.maxWidth);
+            if (!me.setProp('width', width, dirty)) {
+                return NaN;
+            }
+
+            
+            frameBody = me.frameBodyContext;
+            if (frameBody) {
+                frameInfo = me.getFrameInfo();
+                frameBody.setWidth(width - frameInfo.width, dirty);
+            }
+
+            
+        }
+
+        return width;
+    },
+
+    setSize: function (width, height, dirty) {
+        this.setWidth(width, dirty);
+        this.setHeight(height, dirty);
+    },
+
+    translateProps: {
+        x: 'left',
+        y: 'top'
+    },
+
+    undo: function(deep) {
+        var me = this,
+            items, len, i;
+
+        me.revertProps(me.lastBox);
+
+        if (deep && me.wrapsComponent) {
+            
+            if (me.childItems) {
+                for (i = 0, items = me.childItems, len = items.length; i < len; i++) {
+                    items[i].undo(deep);
+                }
+            }
+
+            
+            for (i = 0, items = me.children, len = items.length; i < len; i++) {
+                items[i].undo();
+            }
+        }
+    },
+
+    unsetProp: function (propName) {
+        var dirty = this.dirty;
+
+        delete this.props[propName];
+        if (dirty) {
+            delete dirty[propName];
+        }
+    },
+
+    writeProps: function(dirtyProps, flushing) {
+        if (!(dirtyProps && typeof dirtyProps == 'object')) {
+            return;
+        }
+
+        var me = this,
+            el = me.el,
+            styles = {},
+            styleCount = 0, 
+            styleInfo = me.styleInfo,
+            
+            info,
+            propName,
+            numericValue,
+            
+            dirtyX = 'x' in dirtyProps,
+            dirtyY = 'y' in dirtyProps,
+            x = dirtyProps.x,
+            y = dirtyProps.y,
+            
+            width = dirtyProps.width,
+            height = dirtyProps.height,
+            isBorderBox = me.isBorderBoxValue,
+            target = me.target,
+            max = Math.max,
+            paddingWidth = 0,
+            paddingHeight = 0,
+            hasWidth, hasHeight, isAbsolute, scrollbarSize, style, targetEl;
+
+        
+        if ('displayed' in dirtyProps) {
+            el.setDisplayed(dirtyProps.displayed);
+        }
+
+        
+        for (propName in dirtyProps) {
+            if (flushing) {
+                me.fireTriggers('domTriggers', propName);
+                me.clearBlocks('domBlocks', propName);
+                me.flushedProps[propName] = 1;
+            }
+
+            info = styleInfo[propName];
+            if (info && info.dom) {
+                
+                if (info.suffix && (numericValue = parseInt(dirtyProps[propName], 10))) {
+                    styles[propName] = numericValue + info.suffix;
+                }
+                
+                else {
+                    styles[propName] = dirtyProps[propName];
+                }
+                ++styleCount;
+            }
+        }
+
+        
+        if (dirtyX || dirtyY) {
+            if (target.isComponent) {
+                
+                target.setPosition(x||me.props.x, y||me.props.y);
+            } else {
+                
+                if (dirtyX) {
+                    styles.left = x + 'px';
+                    ++styleCount;
+                }
+                if (dirtyY) {
+                    styles.top = y + 'px';
+                    ++styleCount;
+                }
+            }
+        }
+
+        
+        if (!isBorderBox && (width > 0 || height > 0)) { 
+            
+            
+            if(!me.frameBodyContext) {
+                
+                paddingWidth = me.paddingInfo.width;
+                paddingHeight = me.paddingInfo.height;
+            }
+            if (width) {
+                width = max(parseInt(width, 10) - (me.borderInfo.width + paddingWidth), 0);
+                styles.width = width + 'px';
+                ++styleCount;
+            }
+            if (height) {
+                height = max(parseInt(height, 10) - (me.borderInfo.height + paddingHeight), 0);
+                styles.height = height + 'px';
+                ++styleCount;
+            }
+        }
+
+        
+        
+        
+        
+        
+        
+        if (me.wrapsComponent && Ext.isIE9 && Ext.isStrict) {
+            
+            
+            if ((hasWidth = width !== undefined && me.hasOverflowY) ||
+                (hasHeight = height !== undefined && me.hasOverflowX)) {
+                
+                isAbsolute = me.isAbsolute;
+                if (isAbsolute === undefined) {
+                    isAbsolute = false;
+                    targetEl = me.target.getTargetEl();
+                    style = targetEl.getStyle('position');
+
+                    if (style == 'absolute') {
+                        style = targetEl.getStyle('box-sizing');
+                        isAbsolute = (style == 'border-box');
+                    }
+
+                    me.isAbsolute = isAbsolute; 
+                }
+
+                if (isAbsolute) {
+                    scrollbarSize = Ext.getScrollbarSize();
+
+                    if (hasWidth) {
+                        width = parseInt(width, 10) + scrollbarSize.width;
+                        styles.width = width + 'px';
+                        ++styleCount;
+                    }
+                    if (hasHeight) {
+                        height = parseInt(height, 10) + scrollbarSize.height;
+                        styles.height = height + 'px';
+                        ++styleCount;
+                    }
+                }
+            }
+        }
+
+        
+        if (styleCount) {
+            el.setStyle(styles);
+        }
+    }
+}, function () {
+    
+    var px =    { dom: true, parseInt: true, suffix: 'px' },
+        isDom = { dom: true },
+        faux =  { dom: false };
+
+    
+    
+    
+    
+    
+    
+    
+    
+    this.prototype.styleInfo = {
+        childrenDone:           faux,
+        componentChildrenDone:  faux,
+        containerChildrenDone:  faux,
+        containerLayoutDone:    faux,
+        displayed:              faux,
+        done:                   faux,
+        x:                      faux,
+        y:                      faux,
+
+        
+        columnWidthsDone:       faux,
+
+        left:                   px,
+        top:                    px,
+        right:                  px,
+        bottom:                 px,
+        width:                  px,
+        height:                 px,
+
+        'border-top-width':     px,
+        'border-right-width':   px,
+        'border-bottom-width':  px,
+        'border-left-width':    px,
+
+        'margin-top':           px,
+        'margin-right':         px,
+        'margin-bottom':        px,
+        'margin-left':          px,
+
+        'padding-top':          px,
+        'padding-right':        px,
+        'padding-bottom':       px,
+        'padding-left':         px,
+
+        'line-height':          isDom,
+        display:                isDom
+    };
+});
+
+
+Ext.define('Ext.layout.Context', {
+    requires: [
+        'Ext.util.Queue',
+        'Ext.layout.ContextItem',
+        'Ext.layout.Layout',
+        'Ext.fx.Anim',
+        'Ext.fx.Manager'
+    ],
+
+    remainingLayouts: 0,
+
+    
+    state: 0,
+
+    constructor: function (config) {
+        var me = this;
+
+        Ext.apply(me, config);
+
+        
+        me.items = {};
+
+        
+        me.layouts = {};
+
+        
+        me.blockCount = 0;
+        
+        me.cycleCount = 0;
+        
+        me.flushCount = 0;
+        
+        me.calcCount = 0;
+
+        me.animateQueue = me.newQueue();
+        me.completionQueue = me.newQueue();
+        me.finalizeQueue = me.newQueue();
+        me.finishQueue = me.newQueue();
+        me.flushQueue = me.newQueue();
+
+        me.invalidateData = {};
+
+        
+        me.layoutQueue = me.newQueue();
+
+        
+        
+        me.invalidQueue = [];
+
+        me.triggers = {
+            data: {
+                
+            },
+            dom: {}
+        };
+    },
+
+    callLayout: function (layout, methodName) {
+        this.currentLayout = layout;
+        layout[methodName](this.getCmp(layout.owner));
+    },
+
+    cancelComponent: function (comp, isChild, isDestroying) {
+        var me = this,
+            components = comp,
+            isArray = !comp.isComponent,
+            length = isArray ? components.length : 1,
+            i, k, klen, items, layout, newQueue, oldQueue, entry, temp,
+            ownerCtContext;
+
+        for (i = 0; i < length; ++i) {
+            if (isArray) {
+                comp = components[i];
+            }
+
+            
+            if (isDestroying && comp.ownerCt) {
+                ownerCtContext = this.items[comp.ownerCt.el.id];
+                if (ownerCtContext) {
+                    Ext.Array.remove(ownerCtContext.childItems, me.getCmp(comp));
+                }
+            }
+
+            if (!isChild) {
+                oldQueue = me.invalidQueue;
+                klen = oldQueue.length;
+
+                if (klen) {
+                    me.invalidQueue = newQueue = [];
+                    for (k = 0; k < klen; ++k) {
+                        entry = oldQueue[k];
+                        temp = entry.item.target;
+                        if (temp != comp && !temp.isDescendant(comp)) {
+                            newQueue.push(entry);
+                        }
+                    }
+                }
+            }
+
+            layout = comp.componentLayout;
+            me.cancelLayout(layout);
+
+            if (layout.getLayoutItems) {
+                items = layout.getLayoutItems();
+                if (items.length) {
+                    me.cancelComponent(items, true);
+                }
+            }
+
+            if (comp.isContainer && !comp.collapsed) {
+                layout = comp.layout;
+                me.cancelLayout(layout);
+
+                items = layout.getVisibleItems();
+                if (items.length) {
+                    me.cancelComponent(items, true);
+                }
+            }
+        }
+    },
+
+    cancelLayout: function (layout) {
+        var me = this;
+
+        me.completionQueue.remove(layout);
+        me.finalizeQueue.remove(layout);
+        me.finishQueue.remove(layout);
+        me.layoutQueue.remove(layout);
+
+        if (layout.running) {
+            me.layoutDone(layout);
+        }
+
+        layout.ownerContext = null;
+    },
+
+    clearTriggers: function (layout, inDom) {
+        var id = layout.id,
+            collection = this.triggers[inDom ? 'dom' : 'data'],
+            triggers = collection && collection[id],
+            length = (triggers && triggers.length) || 0,
+            collection, i, item, trigger;
+
+        for (i = 0; i < length; ++i) {
+            trigger = triggers[i];
+            item = trigger.item;
+
+            collection = inDom ? item.domTriggers : item.triggers;
+            delete collection[trigger.prop][id];
+        }
+    },
+
+    
+    flush: function () {
+        var me = this,
+            items = me.flushQueue.clear(),
+            length = items.length, i;
+
+        if (length) {
+            ++me.flushCount;
+
+            for (i = 0; i < length; ++i) {
+                items[i].flush();
+            }
+        }
+    },
+
+    flushAnimations: function() {
+        var me = this,
+            items = me.animateQueue.clear(),
+            len = items.length,
+            i;
+
+        if (len) {
+            for (i = 0; i < len; i++) {
+                
+                
+                
+                if (items[i].target.animate !== false) {
+                    items[i].flushAnimations();
+                }
+            }
+
+            
+            
+            Ext.fx.Manager.runner();
+        }
+    },
+
+    flushInvalidates: function () {
+        var me = this,
+            queue = me.invalidQueue,
+            length = queue && queue.length,
+            comp, components, entry, i;
+
+        me.invalidQueue = [];
+
+        if (length) {
+            components = [];
+            for (i = 0; i < length; ++i) {
+                comp = (entry = queue[i]).item.target;
+                
+                
+                
+                
+                if (!comp.container.isDetachedBody) {
+                    components.push(comp);
+
+                    if (entry.options) {
+                        me.invalidateData[comp.id] = entry.options;
+                    }
+                }
+            }
+
+            me.invalidate(components, null);
+        }
+    },
+
+    flushLayouts: function (queueName, methodName, dontClear) {
+        var me = this,
+            layouts = dontClear ? me[queueName].items : me[queueName].clear(),
+            length = layouts.length,
+            i, layout;
+
+        if (length) {
+            for (i = 0; i < length; ++i) {
+                layout = layouts[i];
+                if (!layout.running) {
+                    me.callLayout(layout, methodName);
+                }
+            }
+            me.currentLayout = null;
+        }
+    },
+
+    
+    getCmp: function (cmp) {
+        return this.getItem(cmp, cmp.el);
+    },
+
+    
+    getEl: function (parent, el) {
+        var item = this.getItem(el, el);
+
+        if (!item.parent) {
+            item.parent = parent;
+
+            
+            
+            
+            if (parent.children.length) {
+                parent.children.push(item);
+            } else {
+                parent.children = [ item ]; 
+            }
+        }
+
+        return item;
+    },
+
+    getItem: function (target, el) {
+        var id = el.id,
+            items = this.items,
+            item = items[id] ||
+                  (items[id] = new Ext.layout.ContextItem({
+                                    context: this,
+                                    target: target,
+                                    el: el
+                                }));
+
+        return item;
+    },
+
+    handleFailure: function () {
+        
+        
+        
+        var layouts = this.layouts,
+            layout, key;
+
+        Ext.failedLayouts = (Ext.failedLayouts || 0) + 1;
+
+        for (key in layouts) {
+            layout = layouts[key];
+
+            if (layouts.hasOwnProperty(key)) {
+                layout.running      = false;
+                layout.ownerContext = null;
+            }
+        }
+    },
+
+    
+    invalidate: function (components, full) {
+        var me = this,
+            isArray = !components.isComponent,
+            componentChildrenDone, containerChildrenDone, containerLayoutDone,
+            firstTime, i, comp, item, items, length, componentLayout, layout,
+            invalidateOptions, token;
+
+        for (i = 0, length = isArray ? components.length : 1; i < length; ++i) {
+            comp = isArray ? components[i] : components;
+
+            if (comp.rendered && !comp.hidden) {
+                item = me.getCmp(comp);
+                componentLayout = comp.componentLayout;
+                firstTime = !componentLayout.ownerContext;
+                layout = (comp.isContainer && !comp.collapsed) ? comp.layout : null;
+
+                
+                invalidateOptions = me.invalidateData[item.id];
+                delete me.invalidateData[item.id];
+
+                
+                
+                
+                
+                
+                
+                token = item.init(full, invalidateOptions);
+
+                if (invalidateOptions) {
+                    me.processInvalidate(invalidateOptions, item, 'before');
+                }
+
+                
+                
+                
+                if (componentLayout.beforeLayoutCycle) {
+                    componentLayout.beforeLayoutCycle(item);
+                }
+
+                
+                
+                token = item.initContinue(token);
+
+                
+                
+                componentChildrenDone = containerChildrenDone = containerLayoutDone = true;
+
+                
+                
+                
+                
+                if (componentLayout.getLayoutItems) {
+                    componentLayout.renderChildren();
+
+                    items = componentLayout.getLayoutItems();
+                    if (items.length) {
+                        me.invalidate(items, true);
+                        componentChildrenDone = false;
+                    }
+                }
+
+                if (layout) {
+                    containerLayoutDone = false;
+                    layout.renderChildren();
+
+                    items = layout.getVisibleItems();
+                    if (items.length) {
+                        me.invalidate(items, true);
+                        containerChildrenDone = false;
+                    }
+                }
+
+                
+                
+                item.initDone(token, componentChildrenDone, containerChildrenDone,
+                              containerLayoutDone);
+
+                
+                
+                me.resetLayout(componentLayout, item, firstTime);
+                if (layout) {
+                    me.resetLayout(layout, item, firstTime);
+                }
+
+                
+                
+                
+                item.initAnimation();
+
+                if (invalidateOptions) {
+                    me.processInvalidate(invalidateOptions, item, 'after');
+                }
+            }
+        }
+
+        me.currentLayout = null;
+    },
+
+    layoutDone: function (layout) {
+        var ownerContext = layout.ownerContext,
+            ownerCtContext;
+
+        layout.running = false;
+
+        
+        
+        
+        if (layout.isComponentLayout) {
+            if (ownerContext.measuresBox) {
+                ownerContext.onBoxMeasured(); 
+            }
+
+            ownerContext.setProp('done', true);
+
+            ownerCtContext = ownerContext.ownerCtContext;
+            if (ownerCtContext) {
+                if (ownerContext.target.ownerLayout.isComponentLayout) {
+                    if (! --ownerCtContext.remainingComponentChildLayouts) {
+                        ownerCtContext.setProp('componentChildrenDone', true);
+                    }
+                } else {
+                    if (! --ownerCtContext.remainingContainerChildLayouts) {
+                        ownerCtContext.setProp('containerChildrenDone', true);
+                    }
+                }
+                if (! --ownerCtContext.remainingChildLayouts) {
+                    ownerCtContext.setProp('childrenDone', true);
+                }
+            }
+        } else {
+            ownerContext.setProp('containerLayoutDone', true);
+        }
+
+        --this.remainingLayouts;
+        ++this.progressCount; 
+    },
+
+    newQueue: function () {
+        return new Ext.util.Queue();
+    },
+
+    processInvalidate: function (options, item, name) {
+        
+        
+        if (options[name]) {
+            var me = this,
+                currentLayout = me.currentLayout;
+
+            me.currentLayout = options.layout || null;
+
+            options[name](item, options);
+
+            me.currentLayout = currentLayout;
+        }
+    },
+
+    
+    queueAnimation: function (item) {
+        this.animateQueue.add(item);
+    },
+
+    
+    queueCompletion: function (layout) {
+        this.completionQueue.add(layout);
+    },
+
+    
+    queueFinalize: function (layout) {
+        this.finalizeQueue.add(layout);
+    },
+
+    
+    queueFlush: function (item) {
+        this.flushQueue.add(item);
+    },
+
+    chainFns: function (oldOptions, newOptions, funcName) {
+        var me = this,
+            oldLayout = oldOptions.layout,
+            newLayout = newOptions.layout,
+            oldFn = oldOptions[funcName],
+            newFn = newOptions[funcName];
+
+        
+        
+        return function (contextItem) {
+            var prev = me.currentLayout;
+            if (oldFn) {
+                me.currentLayout = oldLayout;
+                oldFn.call(oldOptions.scope || oldOptions, contextItem, oldOptions);
+            }
+            me.currentLayout = newLayout;
+            newFn.call(newOptions.scope || newOptions, contextItem, newOptions);
+            me.currentLayout = prev;
+        };
+    },
+
+    
+    queueInvalidate: function (item, options) {
+        var me = this,
+            newQueue = [],
+            oldQueue = me.invalidQueue,
+            index = oldQueue.length,
+            comp, old, oldComp, oldOptions, oldState;
+
+        if (item.isComponent) {
+            item = me.getCmp(comp = item);
+        } else {
+            comp = item.target;
+        }
+
+        item.invalid = true;
+
+        
+        
+        
+        while (index--) {
+            old = oldQueue[index];
+            oldComp = old.item.target;
+
+            if (comp.isDescendant(oldComp)) {
+                return; 
+            }
+
+            if (oldComp == comp) {
+                
+                if (!(oldOptions = old.options)) {
+                    old.options = options;
+                } else if (options) {
+                    if (options.widthModel) {
+                        oldOptions.widthModel = options.widthModel;
+                    }
+                    if (options.heightModel) {
+                        oldOptions.heightModel = options.heightModel;
+                    }
+                    if (!(oldState = oldOptions.state)) {
+                        oldOptions.state = options.state;
+                    } else if (options.state) {
+                        Ext.apply(oldState, options.state);
+                    }
+
+                    if (options.before) {
+                        oldOptions.before = me.chainFns(oldOptions, options, 'before');
+                    }
+                    if (options.after) {
+                        oldOptions.after = me.chainFns(oldOptions, options, 'after');
+                    }
+                }
+
+                
+                return;
+            }
+
+            if (!oldComp.isDescendant(comp)) {
+                newQueue.push(old); 
+            }
+            
+        }
+        
+
+        
+        
+        newQueue.push({ item: item, options: options });
+
+        me.invalidQueue = newQueue;
+    },
+
+    queueItemLayouts: function (item) {
+        var comp = item.isComponent ? item : item.target,
+            layout = comp.componentLayout;
+
+        if (!layout.pending && !layout.invalid && !layout.done) {
+            this.queueLayout(layout);
+        }
+
+        layout = comp.layout;
+        if (layout && !layout.pending && !layout.invalid && !layout.done) {
+            this.queueLayout(layout);
+        }
+    },
+
+    
+    queueLayout: function (layout) {
+        this.layoutQueue.add(layout);
+        layout.pending = true;
+    },
+
+    
+    resetLayout: function (layout, ownerContext, firstTime) {
+        var me = this,
+            ownerCtContext;
+
+        me.currentLayout = layout;
+
+        layout.done = false;
+        layout.pending = true;
+        layout.firedTriggers = 0;
+
+        me.layoutQueue.add(layout);
+
+        if (firstTime) {
+            me.layouts[layout.id] = layout; 
+            layout.running = true;
+
+            if (layout.finishedLayout) {
+                me.finishQueue.add(layout);
+            }
+
+            
+
+            ++me.remainingLayouts;
+            ++layout.layoutCount; 
+
+            layout.ownerContext = ownerContext;
+            layout.beginCount = 0; 
+            layout.blockCount = 0; 
+            layout.calcCount = 0; 
+            layout.triggerCount = 0; 
+
+            
+            if (layout.isComponentLayout && (ownerCtContext = ownerContext.ownerCtContext)) {
+                
+                
+                
+                
+                if (ownerContext.target.ownerLayout.isComponentLayout) {
+                    ++ownerCtContext.remainingComponentChildLayouts;
+                } else {
+                    ++ownerCtContext.remainingContainerChildLayouts;
+                }
+                ++ownerCtContext.remainingChildLayouts;
+            }
+
+            if (!layout.initialized) {
+                layout.initLayout();
+            }
+
+            layout.beginLayout(ownerContext);
+        } else {
+            ++layout.beginCount;
+
+            if (!layout.running) {
+                
+                ++me.remainingLayouts;
+                layout.running = true;
+
+                if (layout.isComponentLayout) {
+                    
+                    
+                    
+                    ownerContext.unsetProp('done');
+
+                    
+                    
+                    
+                    ownerCtContext = ownerContext.ownerCtContext;
+                    if (ownerCtContext) {
+                        if (ownerContext.target.ownerLayout.isComponentLayout) {
+                            if (++ownerCtContext.remainingComponentChildLayouts == 1) {
+                                ownerCtContext.unsetProp('componentChildrenDone');
+                            }
+                        } else {
+                            if (++ownerCtContext.remainingContainerChildLayouts == 1) {
+                                ownerCtContext.unsetProp('containerChildrenDone');
+                            }
+                        }
+                        if (++ownerCtContext.remainingChildLayouts == 1) {
+                            ownerCtContext.unsetProp('childrenDone');
+                        }
+                    }
+                }
+
+                
+                me.completionQueue.remove(layout);
+                me.finalizeQueue.remove(layout);
+            }
+        }
+
+        layout.beginLayoutCycle(ownerContext, firstTime);
+    },
+
+    
+    run: function () {
+        var me = this,
+            flushed = false,
+            watchDog = 100;
+
+        me.flushInvalidates();
+
+        me.state = 1;
+        me.totalCount = me.layoutQueue.getCount();
+
+        
+        
+        
+        
+        
+        
+        me.flush();
+
+        
+        while ((me.remainingLayouts || me.invalidQueue.length) && watchDog--) {
+            if (me.invalidQueue.length) {
+                me.flushInvalidates();
+            }
+
+            
+            if (me.runCycle()) {
+                flushed = false; 
+                
+            } else if (!flushed) {
+                
+                
+                me.flush();
+                flushed = true; 
+
+                me.flushLayouts('completionQueue', 'completeLayout');
+            } else {
+                
+                me.state = 2;
+                break;
+            }
+
+            if (!(me.remainingLayouts || me.invalidQueue.length)) {
+                me.flush();
+                me.flushLayouts('completionQueue', 'completeLayout');
+                me.flushLayouts('finalizeQueue', 'finalizeLayout');
+            }
+        }
+
+        return me.runComplete();
+    },
+
+    runComplete: function () {
+        var me = this;
+
+        me.state = 2;
+
+        if (me.remainingLayouts) {
+            me.handleFailure();
+            return false;
+        }
+
+        me.flush();
+
+        
+        me.flushLayouts('finishQueue', 'finishedLayout', true);
+
+        
+        me.flushLayouts('finishQueue', 'notifyOwner');
+
+        me.flush(); 
+
+        me.flushAnimations();
+
+        return true;
+    },
+
+    
+    runCycle: function () {
+        var me = this,
+            layouts = me.layoutQueue.clear(),
+            length = layouts.length,
+            i;
+
+        ++me.cycleCount;
+
+        
+        
+        me.progressCount = 0;
+
+        for (i = 0; i < length; ++i) {
+            me.runLayout(me.currentLayout = layouts[i]);
+        }
+
+        me.currentLayout = null;
+
+        return me.progressCount > 0;
+    },
+
+    
+    runLayout: function (layout) {
+        var me = this,
+            ownerContext = me.getCmp(layout.owner);
+
+        layout.pending = false;
+
+        if (ownerContext.state.blocks) {
+            return;
+        }
+
+        
+        
+        
+        
+        layout.done = true;
+
+        ++layout.calcCount;
+        ++me.calcCount;
+
+        layout.calculate(ownerContext);
+
+        if (layout.done) {
+            me.layoutDone(layout);
+
+            if (layout.completeLayout) {
+                me.queueCompletion(layout);
+            }
+            if (layout.finalizeLayout) {
+                me.queueFinalize(layout);
+            }
+        } else if (!layout.pending && !layout.invalid && !(layout.blockCount + layout.triggerCount - layout.firedTriggers)) {
+            
+            
+            me.queueLayout(layout);
+        }
+    },
+
+    
+    setItemSize: function(item, width, height) {
+        var items = item,
+            len = 1,
+            contextItem, i;
+
+        
+        
+        
+        
+        
+
+        if (item.isComposite) {
+            items = item.elements;
+            len = items.length;
+            item = items[0];
+        } else if (!item.dom && !item.el) { 
+            len = items.length;
+            item = items[0];
+        }
+        
+
+        for (i = 0; i < len; ) {
+            contextItem = this.get(item);
+            contextItem.setSize(width, height);
+
+            item = items[++i]; 
+        }
+    }
+});
+
+
+Ext.define('Ext.layout.component.Tab', {
+
+    extend: 'Ext.layout.component.Button',
+    alias: 'layout.tab',
+
+    beginLayout: function(ownerContext) {
+        var me = this,
+            closable = me.owner.closable;
+
+        
+        
+        if (me.lastClosable !== closable) {
+            me.lastClosable = closable;
+            me.clearTargetCache();
+        }
+
+        me.callParent(arguments);
+    }
+});
+
+
+Ext.define('Ext.layout.component.field.Slider', {
+
+    
+
+    alias: ['layout.sliderfield'],
+
+    extend: 'Ext.layout.component.field.Field',
+
+    
+
+    type: 'sliderfield',
+
+    beginLayout: function(ownerContext) {
+        this.callParent(arguments);
+
+        ownerContext.endElContext   = ownerContext.getEl('endEl');
+        ownerContext.innerElContext = ownerContext.getEl('innerEl');
+        ownerContext.bodyElContext  = ownerContext.getEl('bodyEl');
+    },
+
+    publishInnerHeight: function (ownerContext, height) {
+        var innerHeight = height - this.measureLabelErrorHeight(ownerContext),
+            endElPad,
+            inputPad;
+        if (this.owner.vertical) {
+            endElPad = ownerContext.endElContext.getPaddingInfo();
+            inputPad = ownerContext.inputContext.getPaddingInfo();
+            ownerContext.innerElContext.setHeight(innerHeight - inputPad.height - endElPad.height);
+        } else {
+            ownerContext.bodyElContext.setHeight(innerHeight);
+        }
+    },
+
+    publishInnerWidth: function (ownerContext, width) {
+        if (!this.owner.vertical) {
+            var endElPad = ownerContext.endElContext.getPaddingInfo(),
+                inputPad = ownerContext.inputContext.getPaddingInfo();
+
+            ownerContext.innerElContext.setWidth(width - inputPad.left - endElPad.right - ownerContext.labelContext.getProp('width'));
+        }
+    },
+
+    beginLayoutFixed: function(ownerContext, width, suffix) {
+        var me = this,
+            ieInputWidthAdjustment = me.ieInputWidthAdjustment;
+
+        if (ieInputWidthAdjustment) {
+            
+            
+            me.owner.bodyEl.setStyle('padding-right', ieInputWidthAdjustment + 'px');
+        }
+
+        me.callParent(arguments);
+    }
+});
+
+
+Ext.define('Ext.layout.container.Absolute', {
+
+    
+
+    alias: 'layout.absolute',
+    extend: 'Ext.layout.container.Anchor',
+    alternateClassName: 'Ext.layout.AbsoluteLayout',
+
+    
+
+    targetCls: Ext.baseCSSPrefix + 'abs-layout-ct',
+    itemCls: Ext.baseCSSPrefix + 'abs-layout-item',
+
+    
+    ignoreOnContentChange: true,
+
+    type: 'absolute',
+
+    
+    adjustWidthAnchor: function(value, childContext) {
+        var padding = this.targetPadding,
+            x = childContext.getStyle('left');
+
+        return value - x + padding.left;
+    },
+
+    
+    adjustHeightAnchor: function(value, childContext) {
+        var padding = this.targetPadding,
+            y = childContext.getStyle('top');
+
+        return value - y + padding.top;
+    },
+
+    isItemLayoutRoot: function (item) {
+        return this.ignoreOnContentChange || this.callParent(arguments);
+    },
+
+    isItemShrinkWrap: function (item) {
+        return true;
+    },
+
+    beginLayout: function (ownerContext) {
+        var me = this,
+            target = me.getTarget();
+
+        me.callParent(arguments);
+
+        
+        if (target.dom !== document.body) {
+            target.position();
+        }
+
+        me.targetPadding = ownerContext.targetContext.getPaddingInfo();
+    },
+
+    isItemBoxParent: function (itemContext) {
+        return true;
+    },
+
+    onContentChange: function () {
+        if (this.ignoreOnContentChange) {
+            return false;
+        }
+        return this.callParent(arguments);
+    }
+});
+
+
+Ext.define('Ext.layout.container.Accordion', {
+    extend: 'Ext.layout.container.VBox',
+    alias: ['layout.accordion'],
+    alternateClassName: 'Ext.layout.AccordionLayout',
+
+    itemCls: [Ext.baseCSSPrefix + 'box-item', Ext.baseCSSPrefix + 'accordion-item'],
+
+    align: 'stretch',
+
+    
+    fill : true,
+
+    
+
+    
+    titleCollapse : true,
+
+    
+    hideCollapseTool : false,
+
+    
+    collapseFirst : false,
+
+    
+    animate : true,
+    
+    activeOnTop : false,
+    
+    multi: false,
+    
+    defaultAnimatePolicy: {
+        y: true,
+        height: true
+    },
+
+    constructor: function() {
+        var me = this;
+
+        me.callParent(arguments);
+
+        if (me.animate) {
+            me.animatePolicy = Ext.apply({}, me.defaultAnimatePolicy);
+        } else {
+            me.animatePolicy = null;
+        }
+    },
+
+    beforeRenderItems: function (items) {
+        var me = this,
+            ln = items.length,
+            i = 0,
+            comp;
+
+        for (; i < ln; i++) {
+            comp = items[i];
+            if (!comp.rendered) {
+                
+                if (me.collapseFirst) {
+                    comp.collapseFirst = me.collapseFirst;
+                }
+                if (me.hideCollapseTool) {
+                    comp.hideCollapseTool = me.hideCollapseTool;
+                    comp.titleCollapse = true;
+                }
+                else if (me.titleCollapse) {
+                    comp.titleCollapse = me.titleCollapse;
+                }
+
+                delete comp.hideHeader;
+                delete comp.width;
+                comp.collapsible = true;
+                comp.title = comp.title || '&#160;';
+                comp.addBodyCls(Ext.baseCSSPrefix + 'accordion-body');
+
+                
+                
+                if (!me.multi) {
+                    
+                    if (me.expandedItem !== undefined) {
+                        comp.collapsed = true;
+                    }
+                    
+                    else if (comp.hasOwnProperty('collapsed') && comp.collapsed === false) {
+                        me.expandedItem = i;
+                    } else {
+                        comp.collapsed = true;
+                    }
+
+                    
+                    me.owner.mon(comp, {
+                        show: me.onComponentShow,
+                        beforeexpand: me.onComponentExpand,
+                        scope: me
+                    });
+                }
+
+                
+                
+                if (me.fill) {
+                    me.owner.mon(comp, {
+                        beforecollapse: me.onComponentCollapse,
+                        scope: me
+                    });
+                }
+            }
+        }
+
+        
+        if (ln && me.expandedItem === undefined) {
+            me.expandedItem = 0;
+            items[0].collapsed = false;
+        }
+    },
+
+    getItemsRenderTree: function(items) {
+        this.beforeRenderItems(items);
+
+        return this.callParent(arguments);
+    },
+
+    renderItems : function(items, target) {
+        this.beforeRenderItems(items);
+
+        this.callParent(arguments);
+    },
+
+    configureItem: function(item) {
+        this.callParent(arguments);
+
+        
+        
+        item.animCollapse = item.border = false;
+
+        
+        if (this.fill) {
+            item.flex = 1;
+        }
+    },
+
+    onChildPanelRender: function(panel) {
+        panel.header.addCls(Ext.baseCSSPrefix + 'accordion-hd');
+    },
+
+    beginLayout: function (ownerContext) {
+        this.callParent(arguments);
+        this.updatePanelClasses(ownerContext);
+    },
+
+    updatePanelClasses: function(ownerContext) {
+        var children = ownerContext.visibleItems,
+            ln = children.length,
+            siblingCollapsed = true,
+            i, child, header;
+
+        for (i = 0; i < ln; i++) {
+            child = children[i];
+            header = child.header;
+            header.addCls(Ext.baseCSSPrefix + 'accordion-hd');
+
+            if (siblingCollapsed) {
+                header.removeCls(Ext.baseCSSPrefix + 'accordion-hd-sibling-expanded');
+            } else {
+                header.addCls(Ext.baseCSSPrefix + 'accordion-hd-sibling-expanded');
+            }
+
+            if (i + 1 == ln && child.collapsed) {
+                header.addCls(Ext.baseCSSPrefix + 'accordion-hd-last-collapsed');
+            } else {
+                header.removeCls(Ext.baseCSSPrefix + 'accordion-hd-last-collapsed');
+            }
+
+            siblingCollapsed = child.collapsed;
+        }
+    },
+
+    
+    
+    
+    onComponentExpand: function(toExpand) {
+        var me = this,
+            owner = me.owner,
+            expanded,
+            expandedCount, i,
+            previousValue;
+
+        if (!me.processing) {
+            me.processing = true;
+            previousValue = owner.deferLayouts;
+            owner.deferLayouts = true;
+            expanded = me.multi ? [] : owner.query('>panel:not([collapsed])');
+            expandedCount = expanded.length;
+            
+            
+            for (i = 0; i < expandedCount; i++) {
+                expanded[i].collapse();
+            }
+            owner.deferLayouts = previousValue;
+            me.processing = false;
+        }
+    },
+
+    onComponentCollapse: function(comp) {
+        var me = this,
+            owner = me.owner,
+            toExpand,
+            expanded,
+            previousValue;
+
+        if (me.owner.items.getCount() === 1) {
+            
+            return false;
+        }
+
+        if (!me.processing) {
+            me.processing = true;
+            previousValue = owner.deferLayouts;
+            owner.deferLayouts = true;
+            toExpand = comp.next() || comp.prev();
+
+            
+            
+            if (me.multi) {
+                expanded = me.owner.query('>panel:not([collapsed])');
+
+                
+                
+                if (expanded.length === 1) {
+                    toExpand.expand();
+                }
+
+            } else if (toExpand) {
+                toExpand.expand();
+            }
+            owner.deferLayouts = previousValue;
+            me.processing = false;
+        }
+    },
+
+    onComponentShow: function(comp) {
+        
+        this.onComponentExpand(comp);
+    }
+});
+
+
+Ext.define('Ext.resizer.Splitter', {
+    extend: 'Ext.Component',
+    requires: ['Ext.XTemplate'],
+    uses: ['Ext.resizer.SplitterTracker'],
+    alias: 'widget.splitter',
+
+    childEls: [
+        'collapseEl'
+    ],
+
+    renderTpl: [
+        '<tpl if="collapsible===true">',
+            '<div id="{id}-collapseEl" class="', Ext.baseCSSPrefix, 'collapse-el ',
+                Ext.baseCSSPrefix, 'layout-split-{collapseDir}">&#160;</div>',
+        '</tpl>'
+    ],
+
+    baseCls: Ext.baseCSSPrefix + 'splitter',
+    collapsedClsInternal: Ext.baseCSSPrefix + 'splitter-collapsed',
+    
+    
+    canResize: true,
+
+    
+    collapsible: false,
+
+    
+
+    
+    collapseOnDblClick: true,
+
+    
+    defaultSplitMin: 40,
+
+    
+    defaultSplitMax: 1000,
+
+    
+
+    
+    collapseTarget: 'next',
+
+    
+
+    horizontal: false,
+    vertical: false,
+
+    
+    getTrackerConfig: function () {
+        return {
+            xclass: 'Ext.resizer.SplitterTracker',
+            el: this.el,
+            splitter: this
+        };
+    },
+
+    beforeRender: function() {
+        var me = this,
+            target = me.getCollapseTarget(),
+            collapseDir = me.getCollapseDirection(),
+            vertical = me.vertical,
+            fixedSizeProp = vertical ? 'width' : 'height',
+            stretchSizeProp = vertical ? 'height' : 'width',
+            cls;
+
+        me.callParent();
+
+        if (!me.hasOwnProperty(stretchSizeProp)) {
+            me[stretchSizeProp] = '100%';
+        }
+        if (!me.hasOwnProperty(fixedSizeProp)) {
+            me[fixedSizeProp] = 5;
+        }
+
+        if (target.collapsed) {
+            me.addCls(me.collapsedClsInternal);
+        }
+        
+        cls = me.baseCls + '-' + me.orientation;
+        me.addCls(cls);
+        if (!me.canResize) {
+            me.addCls(cls + '-noresize');
+        }
+        
+        Ext.applyIf(me.renderData, {
+            collapseDir: collapseDir,
+            collapsible: me.collapsible || target.collapsible
+        });
+    },
+
+    onRender: function() {
+        var me = this;
+
+        me.callParent(arguments);
+
+        
+        if (me.performCollapse !== false) {
+            if (me.renderData.collapsible) {
+                me.mon(me.collapseEl, 'click', me.toggleTargetCmp, me);
+            }
+            if (me.collapseOnDblClick) {
+                me.mon(me.el, 'dblclick', me.toggleTargetCmp, me);
+            }
+        }
+
+        
+        me.mon(me.getCollapseTarget(), {
+            collapse: me.onTargetCollapse,
+            expand: me.onTargetExpand,
+            scope: me
+        });
+
+        me.el.unselectable();
+        if (me.canResize) {
+            me.tracker = Ext.create(me.getTrackerConfig());
+            
+            me.relayEvents(me.tracker, [ 'beforedragstart', 'dragstart', 'dragend' ]);
+        }
+    },
+
+    getCollapseDirection: function() {
+        var me = this,
+            dir = me.collapseDirection,
+            collapseTarget, idx, items, type;
+
+        if (!dir) {
+            collapseTarget = me.collapseTarget;
+            if (collapseTarget.isComponent) {
+                dir = collapseTarget.collapseDirection;
+            }
+
+            if (!dir) {
+                
+                
+                
+                
+                
+                
+                
+                type = me.ownerCt.layout.type;
+                if (collapseTarget.isComponent) {
+                    items = me.ownerCt.items;
+                    idx = Number(items.indexOf(collapseTarget) == items.indexOf(me) - 1) << 1 | Number(type == 'hbox');
+                } else {
+                    idx = Number(me.collapseTarget == 'prev') << 1 | Number(type == 'hbox');
+                }
+
+                
+                dir = ['bottom', 'right', 'top', 'left'][idx];
+            }
+
+            me.collapseDirection = dir;
+        }
+
+        me.orientation = (dir == 'top' || dir == 'bottom') ? 'horizontal' : 'vertical';
+        me[me.orientation] = true;
+
+        return dir;
+    },
+
+    getCollapseTarget: function() {
+        var me = this;
+
+        return me.collapseTarget.isComponent ? me.collapseTarget : me.collapseTarget == 'prev' ? me.previousSibling() : me.nextSibling();
+    },
+
+    onTargetCollapse: function(target) {
+        this.el.addCls([this.collapsedClsInternal, this.collapsedCls]);
+    },
+
+    onTargetExpand: function(target) {
+        this.el.removeCls([this.collapsedClsInternal, this.collapsedCls]);
+    },
+
+    toggleTargetCmp: function(e, t) {
+        var cmp = this.getCollapseTarget(),
+            placeholder = cmp.placeholder,
+            toggle;
+
+        if (placeholder && !placeholder.hidden) {
+            toggle = true;
+        } else {
+            toggle = !cmp.hidden;
+        }
+
+        if (toggle) {
+            if (cmp.collapsed) {
+                cmp.expand();
+            } else if (cmp.collapseDirection) {
+                cmp.collapse();
+            } else {
+                cmp.collapse(this.renderData.collapseDir);
+            }
+        }
+    },
+
+    
+    setSize: function() {
+        var me = this;
+        me.callParent(arguments);
+        if (Ext.isIE && me.el) {
+            me.el.repaint();
+        }
+    },
+    
+    beforeDestroy: function(){
+        Ext.destroy(this.tracker);
+        this.callParent();
+    }
+});
+
+
+Ext.define('Ext.resizer.BorderSplitter', {
+    extend: 'Ext.resizer.Splitter',
+
+    uses: ['Ext.resizer.BorderSplitterTracker'],
+
+    alias: 'widget.bordersplitter',
+
+    
+    collapseTarget: null,
+
+    getTrackerConfig: function () {
+        var trackerConfig = this.callParent();
+
+        trackerConfig.xclass = 'Ext.resizer.BorderSplitterTracker';
+
+        return trackerConfig;
+    }
+});
+
+
+Ext.define('Ext.layout.container.Border', {
+
+    alias: 'layout.border',
+
+    extend: 'Ext.layout.container.Container',
+
+    requires: ['Ext.resizer.BorderSplitter', 'Ext.Component', 'Ext.fx.Anim'],
+
+    alternateClassName: 'Ext.layout.BorderLayout',
+
+
+    targetCls: Ext.baseCSSPrefix + 'border-layout-ct',
+
+    itemCls: [Ext.baseCSSPrefix + 'border-item', Ext.baseCSSPrefix + 'box-item'],
+
+    type: 'border',
+
+    
+    
+    
+
+    
+    padding: undefined,
+
+    percentageRe: /(\d+)%/,
+
+    
+    axisProps: {
+        horz: {
+            borderBegin: 'west',
+            borderEnd: 'east',
+            horizontal: true,
+            posProp: 'x',
+            sizeProp: 'width',
+            sizePropCap: 'Width'
+        },
+        vert: {
+            borderBegin: 'north',
+            borderEnd: 'south',
+            horizontal: false,
+            posProp: 'y',
+            sizeProp: 'height',
+            sizePropCap: 'Height'
+        }
+    },
+
+    
+    centerRegion: null,
+
+    
+    collapseDirections: {
+        north: 'top',
+        south: 'bottom',
+        east: 'right',
+        west: 'left'
+    },
+
+    manageMargins: true,
+
+    panelCollapseAnimate: true,
+
+    panelCollapseMode: 'placeholder',
+
+    
+    regionWeights: {
+        north: 20,
+        south: 10,
+        center: 0,
+        west: -10,
+        east: -20
+    },
+
+    
+    
+
+    
+    beginAxis: function (ownerContext, regions, name) {
+        var me = this,
+            props = me.axisProps[name],
+            isVert = !props.horizontal,
+            sizeProp = props.sizeProp,
+            totalFlex = 0,
+            childItems = ownerContext.childItems,
+            length = childItems.length,
+            center, i, childContext, centerFlex, comp, region, match, size, type, target, placeholder;
+
+        for (i = 0; i < length; ++i) {
+            childContext = childItems[i];
+            comp = childContext.target;
+
+            childContext.layoutPos = {};
+
+            if (comp.region) {
+                childContext.region = region = comp.region;
+
+                childContext.isCenter = comp.isCenter;
+                childContext.isHorz = comp.isHorz;
+                childContext.isVert = comp.isVert;
+
+                childContext.weight = comp.weight || me.regionWeights[region] || 0;
+                regions[comp.id] = childContext;
+
+                if (comp.isCenter) {
+                    center = childContext;
+                    centerFlex = comp.flex;
+                    ownerContext.centerRegion = center;
+
+                    continue;
+                }
+
+                if (isVert !== childContext.isVert) {
+                    continue;
+                }
+
+                
+
+                childContext.reverseWeighting = (region == props.borderEnd);
+
+                size = comp[sizeProp];
+                type = typeof size;
+
+                if (!comp.collapsed) {
+                    if (type == 'string' && (match = me.percentageRe.exec(size))) {
+                        childContext.percentage = parseInt(match[1], 10);
+                    } else if (comp.flex) {
+                        totalFlex += childContext.flex = comp.flex;
+                    }
+                }
+            }
+        }
+
+        
+        if (center) {
+            target = center.target;
+
+            if (placeholder = target.placeholderFor) {
+                if (!centerFlex && isVert === placeholder.collapsedVertical()) {
+                    
+                    centerFlex = 0;
+                    center.collapseAxis = name;
+                }
+            } else if (target.collapsed && (isVert === target.collapsedVertical())) {
+                
+                centerFlex = 0;
+                center.collapseAxis = name;
+            }
+        }
+
+        if (centerFlex == null) {
+            
+            centerFlex = 1;
+        }
+
+        totalFlex += centerFlex;
+
+        return Ext.apply({
+            before         : isVert ? 'top' : 'left',
+            totalFlex      : totalFlex
+        }, props);
+    },
+
+    beginLayout: function (ownerContext) {
+        var me = this,
+            items = me.getLayoutItems(),
+            pad = me.padding,
+            type = typeof pad,
+            padOnContainer = false,
+            childContext, item, length, i, regions, collapseTarget,
+            doShow, hidden, region;
+
+        
+        if (pad) {
+            if (type == 'string' || type == 'number') {
+                pad = Ext.util.Format.parseBox(pad);
+            }
+        } else {
+            pad = ownerContext.getEl('getTargetEl').getPaddingInfo();
+            padOnContainer = true;
+        }
+        ownerContext.outerPad = pad;
+        ownerContext.padOnContainer = padOnContainer;
+
+        for (i = 0, length = items.length; i < length; ++i) {
+            item = items[i];
+            collapseTarget = me.getSplitterTarget(item);
+            if (collapseTarget) {
+                hidden = !!item.hidden;
+                if (!collapseTarget.split) {
+                    if (collapseTarget.isCollapsingOrExpanding) {
+                        doShow = !!collapseTarget.collapsed;
+                    }
+                } else if (hidden !== collapseTarget.hidden) {
+                    doShow = !collapseTarget.hidden;
+                }
+                
+                if (doShow === true) {
+                    item.show();
+                } else if (doShow === false) {
+                    item.hide();
+                }
+            }
+        }
+
+        
+        
+        
+        me.callParent(arguments);
+
+        items = ownerContext.childItems;
+        length = items.length;
+        regions = {};
+
+        ownerContext.borderAxisHorz = me.beginAxis(ownerContext, regions, 'horz');
+        ownerContext.borderAxisVert = me.beginAxis(ownerContext, regions, 'vert');
+
+        
+        
+        
+        for (i = 0; i < length; ++i) {
+            childContext = items[i];
+            collapseTarget = me.getSplitterTarget(childContext.target);
+
+            if (collapseTarget) { 
+                region = regions[collapseTarget.id]
+                if (!region) {
+                        
+                        
+                        
+                        region = ownerContext.getEl(collapseTarget.el, me);
+                        region.region = collapseTarget.region;
+                }
+                childContext.collapseTarget = collapseTarget = region;
+                childContext.weight = collapseTarget.weight;
+                childContext.reverseWeighting = collapseTarget.reverseWeighting;
+                collapseTarget.splitter = childContext;
+                childContext.isHorz = collapseTarget.isHorz;
+                childContext.isVert = collapseTarget.isVert;
+            }
+        }
+
+        
+        me.sortWeightedItems(items, 'reverseWeighting');
+        me.setupSplitterNeighbors(items);
+    },
+
+    calculate: function (ownerContext) {
+        var me = this,
+            containerSize = me.getContainerSize(ownerContext),
+            childItems = ownerContext.childItems,
+            length = childItems.length,
+            horz = ownerContext.borderAxisHorz,
+            vert = ownerContext.borderAxisVert,
+            pad = ownerContext.outerPad,
+            padOnContainer = ownerContext.padOnContainer,
+            i, childContext, childMargins, size, horzPercentTotal, vertPercentTotal;
+
+        horz.begin = pad.left;
+        vert.begin = pad.top;
+        
+        
+        horzPercentTotal = horz.end = horz.flexSpace = containerSize.width + (padOnContainer ? pad.left : -pad.right);
+        vertPercentTotal = vert.end = vert.flexSpace = containerSize.height + (padOnContainer ? pad.top : -pad.bottom);
+
+        
+        
+        for (i = 0; i < length; ++i) {
+            childContext = childItems[i];
+            childMargins = childContext.getMarginInfo();
+
+            
+            if (childContext.isHorz || childContext.isCenter) {
+                horz.addUnflexed(childMargins.width);
+                horzPercentTotal -= childMargins.width;
+            }
+
+            if (childContext.isVert || childContext.isCenter) {
+                vert.addUnflexed(childMargins.height);
+                vertPercentTotal -= childMargins.height;
+            }
+
+            
+            if (!childContext.flex && !childContext.percentage) {
+                if (childContext.isHorz || (childContext.isCenter && childContext.collapseAxis === 'horz')) {
+                    size = childContext.getProp('width');
+
+                    horz.addUnflexed(size);
+
+                    
+                    if (childContext.collapseTarget) {
+                        horzPercentTotal -= size;
+                    }
+                } else if (childContext.isVert || (childContext.isCenter && childContext.collapseAxis === 'vert')) {
+                    size = childContext.getProp('height');
+
+                    vert.addUnflexed(size);
+
+                    
+                    if (childContext.collapseTarget) {
+                        vertPercentTotal -= size;
+                    }
+                }
+                
+            }
+        }
+
+        for (i = 0; i < length; ++i) {
+            childContext = childItems[i];
+            childMargins = childContext.getMarginInfo();
+
+            
+            if (childContext.percentage) {
+                if (childContext.isHorz) {
+                    size = Math.ceil(horzPercentTotal * childContext.percentage / 100);
+                    size = childContext.setWidth(size);
+                    horz.addUnflexed(size);
+                } else if (childContext.isVert) {
+                    size = Math.ceil(vertPercentTotal * childContext.percentage / 100);
+                    size = childContext.setHeight(size);
+                    vert.addUnflexed(size);
+                }
+                
+            }
+        }
+
+
+        
+        
+
+        for (i = 0; i < length; ++i) {
+            childContext = childItems[i];
+
+            if (!childContext.isCenter) {
+                me.calculateChildAxis(childContext, horz);
+                me.calculateChildAxis(childContext, vert);
+            }
+        }
+
+        
+        
+        
+        if (me.finishAxis(ownerContext, vert) + me.finishAxis(ownerContext, horz) < 2) {
+            me.done = false;
+        } else {
+            
+            
+            
+            me.finishPositions(childItems);
+        }
+    },
+
+    
+    calculateChildAxis: function (childContext, axis) {
+        var collapseTarget = childContext.collapseTarget,
+            setSizeMethod = 'set' + axis.sizePropCap,
+            sizeProp = axis.sizeProp,
+            childMarginSize = childContext.getMarginInfo()[sizeProp],
+            region, isBegin, flex, pos, size;
+
+        if (collapseTarget) { 
+            region = collapseTarget.region;
+        } else {
+            region = childContext.region;
+            flex = childContext.flex;
+        }
+
+        isBegin = region == axis.borderBegin;
+
+        if (!isBegin && region != axis.borderEnd) {
+            
+            
+            childContext[setSizeMethod](axis.end - axis.begin - childMarginSize);
+            pos = axis.begin;
+        } else {
+            if (flex) {
+                size = Math.ceil(axis.flexSpace * (flex / axis.totalFlex));
+                size = childContext[setSizeMethod](size);
+            } else if (childContext.percentage) {
+                
+                size = childContext.peek(sizeProp);
+            } else {
+                size = childContext.getProp(sizeProp);
+            }
+
+            size += childMarginSize;
+
+            if (isBegin) {
+                pos = axis.begin;
+                axis.begin += size;
+            } else {
+                axis.end = pos = axis.end - size;
+            }
+        }
+
+        childContext.layoutPos[axis.posProp] = pos;
+    },
+
+    
+    finishAxis: function (ownerContext, axis) {
+        var size = axis.end - axis.begin,
+            center = ownerContext.centerRegion;
+
+        if (center) {
+            center['set' + axis.sizePropCap](size - center.getMarginInfo()[axis.sizeProp]);
+            center.layoutPos[axis.posProp] = axis.begin;
+        }
+
+        return Ext.isNumber(size) ? 1 : 0;
+    },
+
+    
+    finishPositions: function (childItems) {
+        var length = childItems.length,
+            index, childContext;
+
+        for (index = 0; index < length; ++index) {
+            childContext = childItems[index];
+
+            childContext.setProp('x', childContext.layoutPos.x + childContext.marginInfo.left);
+            childContext.setProp('y', childContext.layoutPos.y + childContext.marginInfo.top);
+        }
+    },
+
+    getPlaceholder: function (comp) {
+        return comp.getPlaceholder && comp.getPlaceholder();
+    },
+
+    getSplitterTarget: function (splitter) {
+        var collapseTarget = splitter.collapseTarget;
+
+        if (collapseTarget && collapseTarget.collapsed) {
+            return collapseTarget.placeholder || collapseTarget;
+        }
+
+        return collapseTarget;
+    },
+
+    isItemBoxParent: function (itemContext) {
+        return true;
+    },
+
+    isItemShrinkWrap: function (item) {
+        return true;
+    },
+
+    
+    
+
+    
+    insertSplitter: function (item, index, hidden) {
+        var region = item.region,
+            splitter = {
+                xtype: 'bordersplitter',
+                collapseTarget: item,
+                id: item.id + '-splitter',
+                hidden: hidden,
+                canResize: item.splitterResize !== false
+            },
+            at = index + ((region == 'south' || region == 'east') ? 0 : 1);
+
+        
+        if (item.isHorz) {
+            splitter.height = null;
+        } else {
+            splitter.width = null;
+        }
+
+        if (item.collapseMode == 'mini') {
+            splitter.collapsedCls = item.collapsedCls;
+        }
+
+        item.splitter = this.owner.add(at, splitter);
+    },
+
+    
+    onAdd: function (item, index) {
+        var me = this,
+            placeholderFor = item.placeholderFor,
+            region = item.region,
+            split,
+            hidden;
+
+        me.callParent(arguments);
+
+        if (region) {
+            Ext.apply(item, me.regionFlags[region]);
+
+            if (region == 'center') {
+                me.centerRegion = item;
+            } else {
+                item.collapseDirection = this.collapseDirections[region];
+                split = item.split;
+                hidden = !!item.hidden;
+                if ((item.isHorz || item.isVert) && (split || item.collapseMode == 'mini')) {
+                    me.insertSplitter(item, index, hidden || !split);
+                }
+            }
+
+            if (!item.hasOwnProperty('collapseMode')) {
+                item.collapseMode = me.panelCollapseMode;
+            }
+
+            if (!item.hasOwnProperty('animCollapse')) {
+                if (item.collapseMode != 'placeholder') {
+                    
+                    
+                    item.animCollapse = false;
+                } else {
+                    item.animCollapse = me.panelCollapseAnimate;
+                }
+            }
+        } else if (placeholderFor) {
+            Ext.apply(item, me.regionFlags[placeholderFor.region]);
+            item.region = placeholderFor.region;
+            item.weight = placeholderFor.weight;
+        }
+    },
+
+    onDestroy: function() {
+        this.centerRegion = null;
+        this.callParent();
+    },
+
+    onRemove: function (item) {
+        var me = this,
+            region = item.region,
+            splitter = item.splitter;
+
+        if (region) {
+            if (item.isCenter) {
+                me.centerRegion = null;
+            }
+
+            delete item.isCenter;
+            delete item.isHorz;
+            delete item.isVert;
+
+            if (splitter) {
+                me.owner.doRemove(splitter, true); 
+                delete item.splitter;
+            }
+        }
+
+        me.callParent(arguments);
+    },
+
+    
+    
+
+    regionFlags: {
+        center: { isCenter: true, isHorz: false, isVert: false },
+
+        north: { isCenter: false, isHorz: false, isVert: true },
+        south: { isCenter: false, isHorz: false, isVert: true },
+
+        west: { isCenter: false, isHorz: true, isVert: false },
+        east: { isCenter: false, isHorz: true, isVert: false }
+    },
+
+    setupSplitterNeighbors: function (items) {
+        var edgeRegions = {
+                
+                
+                
+                
+            },
+            length = items.length,
+            touchedRegions = this.touchedRegions,
+            i, j, center, count, edge, comp, region, splitter, touched;
+
+        for (i = 0; i < length; ++i) {
+            comp = items[i].target;
+            region = comp.region;
+
+            if (comp.isCenter) {
+                center = comp;
+            } else if (region) {
+                touched = touchedRegions[region];
+
+                for (j = 0, count = touched.length; j < count; ++j) {
+                    edge = edgeRegions[touched[j]];
+                    if (edge) {
+                        edge.neighbors.push(comp);
+                    }
+                }
+                
+                if (comp.placeholderFor) {
+                    
+                    splitter = comp.placeholderFor.splitter;
+                } else {
+                    splitter = comp.splitter;
+                }
+                if (splitter) {
+                    splitter.neighbors = [];
+                }
+
+                edgeRegions[region] = splitter;
+            }
+        }
+
+        if (center) {
+            touched = touchedRegions.center;
+
+            for (j = 0, count = touched.length; j < count; ++j) {
+                edge = edgeRegions[touched[j]];
+                if (edge) {
+                    edge.neighbors.push(center);
+                }
+            }
+        }
+    },
+
+    
+    touchedRegions: {
+        center: [ 'north', 'south', 'east',  'west' ],
+
+        north:  [ 'north', 'east',  'west'  ],
+        south:  [ 'south', 'east',  'west'  ],
+        east:   [ 'east',  'north', 'south' ],
+        west:   [ 'west',  'north', 'south' ]
+    },
+
+    sizePolicies: {
+        vert: {
+            setsWidth: 1,
+            setsHeight: 0
+        },
+        horz: {
+            setsWidth: 0,
+            setsHeight: 1
+        },
+        flexAll: {
+            setsWidth: 1,
+            setsHeight: 1
+        }
+    },
+
+    getItemSizePolicy: function (item) {
+        var me = this,
+            policies = this.sizePolicies,
+            collapseTarget, size, policy, placeholderFor;
+
+        if (item.isCenter) {
+            placeholderFor = item.placeholderFor;
+
+            if (placeholderFor) {
+                if (placeholderFor.collapsedVertical()) {
+                    return policies.vert;
+                }
+                return policies.horz;
+            }
+            if (item.collapsed) {
+                if (item.collapsedVertical()) {
+                    return policies.vert;
+                }
+                return policies.horz;
+            }
+            return policies.flexAll;
+        }
+
+        collapseTarget = item.collapseTarget;
+
+        if (collapseTarget) {
+            return collapseTarget.isVert ? policies.vert : policies.horz;
+        }
+
+        if (item.region) {
+            if (item.isVert) {
+                size = item.height;
+                policy = policies.vert;
+            } else {
+                size = item.width;
+                policy = policies.horz;
+            }
+
+            if (item.flex || (typeof size == 'string' && me.percentageRe.test(size))) {
+                return policies.flexAll;
+            }
+
+            return policy;
+        }
+
+        return me.autoSizePolicy;
+    }
+}, function () {
+    var methods = {
+        addUnflexed: function (px) {
+            this.flexSpace = Math.max(this.flexSpace - px, 0);
+        }
+    },
+    props = this.prototype.axisProps;
+
+    Ext.apply(props.horz, methods);
+    Ext.apply(props.vert, methods);
+});
+
+
+Ext.define('Ext.layout.container.Card', {
+
+    
+
+    extend: 'Ext.layout.container.Fit',
+
+    alternateClassName: 'Ext.layout.CardLayout',
+
+    alias: 'layout.card',
+
+    
+
+    type: 'card',
+
+    hideInactive: true,
+
+    
+    deferredRender : false,
+    
+    getRenderTree: function () {
+        var me = this,
+            activeItem = me.getActiveItem();
+
+        if (activeItem) {
+
+            
+            if (activeItem.hasListeners.beforeactivate && activeItem.fireEvent('beforeactivate', activeItem) === false) {
+ 
+                
+                
+                
+                activeItem = me.activeItem = me.owner.activeItem = null;
+            }
+            
+            
+            else if (activeItem.hasListeners.activate) {
+                activeItem.on({
+                    boxready: function() {
+                        activeItem.fireEvent('activate', activeItem);
+                    },
+                    single: true
+                });
+            }
+
+            if (me.deferredRender) {
+                if (activeItem) {
+                    return me.getItemsRenderTree([activeItem]);
+                }
+            } else {
+                return me.callParent(arguments);
+            }
+        }
+    },
+
+    renderChildren: function () {
+        var me = this,
+            active = me.getActiveItem();
+            
+        if (!me.deferredRender) {
+            me.callParent();
+        } else if (active) {
+            
+            me.renderItems([active], me.getRenderTarget());
+        }
+    },
+
+    isValidParent : function(item, target, position) {
+        
+        
+        var itemEl = item.el ? item.el.dom : Ext.getDom(item);
+        return (itemEl && itemEl.parentNode === (target.dom || target)) || false;
+    },
+
+    
+    getActiveItem: function() {
+        var me = this,
+            
+            result = me.parseActiveItem(me.activeItem || (me.owner && me.owner.activeItem));
+
+        
+        if (result && me.owner.items.indexOf(result) != -1) {
+            me.activeItem = result;
+        } else {
+            me.activeItem = null;
+        }
+
+        return me.activeItem;
+    },
+
+    
+    parseActiveItem: function(item) {
+        if (item && item.isComponent) {
+            return item;
+        } else if (typeof item == 'number' || item === undefined) {
+            return this.getLayoutItems()[item || 0];
+        } else {
+            return this.owner.getComponent(item);
+        }
+    },
+
+    
+    
+    configureItem: function(item) {
+        if (item === this.getActiveItem()) {
+            item.hidden = false;
+        } else {
+            item.hidden = true;
+        }
+        this.callParent(arguments);
+    },
+
+    onRemove: function(component) {
+        var me = this;
+        
+        if (component === me.activeItem) {
+            me.activeItem = null;
+        }
+    },
+
+    
+    getAnimation: function(newCard, owner) {
+        var newAnim = (newCard || {}).cardSwitchAnimation;
+        if (newAnim === false) {
+            return false;
+        }
+        return newAnim || owner.cardSwitchAnimation;
+    },
+
+    
+    getNext: function() {
+        
+        
+        var wrap = arguments[0],
+            items = this.getLayoutItems(),
+            index = Ext.Array.indexOf(items, this.activeItem);
+            
+        return items[index + 1] || (wrap ? items[0] : false);
+    },
+
+    
+    next: function() {
+        
+        
+        var anim = arguments[0], 
+            wrap = arguments[1];
+        return this.setActiveItem(this.getNext(wrap), anim);
+    },
+
+    
+    getPrev: function() {
+        
+        
+        var wrap = arguments[0],
+            items = this.getLayoutItems(),
+            index = Ext.Array.indexOf(items, this.activeItem);
+            
+        return items[index - 1] || (wrap ? items[items.length - 1] : false);
+    },
+
+    
+    prev: function() {
+        
+        
+        var anim = arguments[0], 
+            wrap = arguments[1];
+        return this.setActiveItem(this.getPrev(wrap), anim);
+    },
+
+    
+    setActiveItem: function(newCard) {
+        var me = this,
+            owner = me.owner,
+            oldCard = me.activeItem,
+            rendered = owner.rendered,
+            newIndex;
+
+        newCard = me.parseActiveItem(newCard);
+        newIndex = owner.items.indexOf(newCard);
+
+        
+        
+        if (newIndex == -1) {
+            newIndex = owner.items.items.length;
+            Ext.suspendLayouts();
+            newCard = owner.add(newCard);
+            Ext.resumeLayouts();
+        }
+
+        
+        if (newCard && oldCard != newCard) {
+            
+            if (newCard.fireEvent('beforeactivate', newCard, oldCard) === false) {
+                return false;
+            }
+            if (oldCard && oldCard.fireEvent('beforedeactivate', oldCard, newCard) === false) {
+                return false;
+            }
+
+            if (rendered) {
+                Ext.suspendLayouts();
+
+                
+                if (!newCard.rendered) {
+                    me.renderItem(newCard, me.getRenderTarget(), owner.items.length);
+                }
+
+                if (oldCard) {
+                    if (me.hideInactive) {
+                        oldCard.hide();
+                        oldCard.hiddenByLayout = true;
+                    }
+                    oldCard.fireEvent('deactivate', oldCard, newCard);
+                }
+                
+                if (newCard.hidden) {
+                    newCard.show();
+                }
+
+                
+                if (!newCard.hidden) {
+                    me.activeItem = newCard;
+                }
+                Ext.resumeLayouts(true);
+            } else {
+                me.activeItem = newCard;
+            }
+
+            newCard.fireEvent('activate', newCard, oldCard);
+
+            return me.activeItem;
+        }
+        return false;
+    }
+});
+
+
+Ext.define('Ext.layout.container.Column', {
+
+    extend: 'Ext.layout.container.Container',
+    alias: ['layout.column'],
+    alternateClassName: 'Ext.layout.ColumnLayout',
+
+    type: 'column',
+
+    itemCls: Ext.baseCSSPrefix + 'column',
+
+    targetCls: Ext.baseCSSPrefix + 'column-layout-ct',
+
+    
+    columnWidthSizePolicy: {
+        setsWidth: 1,
+        setsHeight: 0
+    },
+
+    childEls: [
+        'innerCt'
+    ],
+
+    manageOverflow: 2,
+
+    renderTpl: [
+        '<div id="{ownerId}-innerCt" class="',Ext.baseCSSPrefix,'column-inner">',
+            '{%this.renderBody(out,values)%}',
+            '<div class="',Ext.baseCSSPrefix,'clear"></div>',
+        '</div>',
+        '{%this.renderPadder(out,values)%}'
+    ],
+
+    getItemSizePolicy: function (item) {
+        if (item.columnWidth) {
+            return this.columnWidthSizePolicy;
+        }
+        return this.autoSizePolicy;
+    },
+
+    beginLayout: function() {
+        this.callParent(arguments);
+        this.innerCt.dom.style.width = '';
+    },
+
+    calculate: function (ownerContext) {
+        var me = this,
+            containerSize = me.getContainerSize(ownerContext),
+            state = ownerContext.state;
+
+        if (state.calculatedColumns || (state.calculatedColumns = me.calculateColumns(ownerContext))) {
+            if (me.calculateHeights(ownerContext)) {
+                me.calculateOverflow(ownerContext, containerSize);
+                return;
+            }
+        }
+
+        me.done = false;
+    },
+
+    calculateColumns: function (ownerContext) {
+        var me = this,
+            containerSize = me.getContainerSize(ownerContext),
+            innerCtContext = ownerContext.getEl('innerCt', me),
+            items = ownerContext.childItems,
+            len = items.length,
+            contentWidth = 0,
+            blocked, availableWidth, i, itemContext, itemMarginWidth, itemWidth;
+
+        
+        
+        
+        if (!ownerContext.heightModel.shrinkWrap && !ownerContext.targetContext.hasProp('height')) {
+            return false;
+        }
+
+        
+        if (!containerSize.gotWidth) { 
+            ownerContext.targetContext.block(me, 'width');
+            blocked = true;
+        } else {
+            availableWidth = containerSize.width;
+
+            innerCtContext.setWidth(availableWidth);
+        }
+
+        
+        
+        for (i = 0; i < len; ++i) {
+            itemContext = items[i];
+
+            
+            
+            
+            itemMarginWidth = itemContext.getMarginInfo().width;
+
+            if (!itemContext.widthModel.calculated) {
+                itemWidth = itemContext.getProp('width');
+                if (typeof itemWidth != 'number') {
+                    itemContext.block(me, 'width');
+                    blocked = true;
+                }
+
+                contentWidth += itemWidth + itemMarginWidth;
+            }
+        }
+
+        if (!blocked) {
+            availableWidth = (availableWidth < contentWidth) ? 0 : availableWidth - contentWidth;
+
+            for (i = 0; i < len; ++i) {
+                itemContext = items[i];
+                if (itemContext.widthModel.calculated) {
+                    itemMarginWidth = itemContext.marginInfo.width; 
+                    itemWidth = itemContext.target.columnWidth;
+                    itemWidth = Math.floor(itemWidth * availableWidth) - itemMarginWidth;
+                    itemWidth = itemContext.setWidth(itemWidth); 
+                    contentWidth += itemWidth + itemMarginWidth;
+                }
+            }
+
+            ownerContext.setContentWidth(contentWidth);
+        }
+
+        
+        return !blocked;
+    },
+
+    calculateHeights: function (ownerContext) {
+        var me = this,
+            items = ownerContext.childItems,
+            len = items.length,
+            blocked, i, itemContext;
+
+        
+        
+        blocked = false;
+        for (i = 0; i < len; ++i) {
+            itemContext = items[i];
+
+            if (!itemContext.hasDomProp('height')) {
+                itemContext.domBlock(me, 'height');
+                blocked = true;
+            }
+        }
+
+        if (!blocked) {
+            ownerContext.setContentHeight(me.innerCt.getHeight() + ownerContext.targetContext.getPaddingInfo().height);
+        }
+
+        return !blocked;
+    },
+
+    finishedLayout: function (ownerContext) {
+        var bc = ownerContext.bodyContext;
+
+        
+        if (bc && (Ext.isIE6 || Ext.isIE7 || Ext.isIEQuirks)) {
+            
+            bc.el.repaint();
+        }
+
+        this.callParent(arguments);
+    },
+
+    getRenderTarget : function() {
+        return this.innerCt;
+    }
+});
+
+
+Ext.define('Ext.layout.container.Form', {
+
+    
+
+    alias: 'layout.form',
+    extend: 'Ext.layout.container.Auto',
+    alternateClassName: 'Ext.layout.FormLayout',
+
+    
+   
+    tableCls: Ext.baseCSSPrefix + 'form-layout-table',
+
+    type: 'form',
+
+    manageOverflow: 2,
+
+    childEls: ['formTable'],
+    
+    padRow: '<tr><td class="' + Ext.baseCSSPrefix + 'form-item-pad" colspan="3"></td></tr>',
+
+    renderTpl: [
+        '<table id="{ownerId}-formTable" class="{tableCls}" style="width:100%" cellpadding="0">',
+            '{%this.renderBody(out,values)%}',
+        '</table>',
+        '{%this.renderPadder(out,values)%}'
+    ],
+    
+    getRenderData: function(){
+        var data = this.callParent();
+        data.tableCls = this.tableCls;
+        return data;    
+    },
+
+    calculate : function (ownerContext) {
+        var me = this,
+            containerSize = me.getContainerSize(ownerContext, true),
+            tableWidth,
+            childItems,
+            i = 0, length;
+
+        
+        if (containerSize.gotWidth) {
+            this.callParent(arguments);
+            tableWidth = me.formTable.dom.offsetWidth;
+            childItems = ownerContext.childItems;
+
+            for (length = childItems.length; i < length; ++i) {
+                childItems[i].setWidth(tableWidth, false);
+            }
+        } else {
+            me.done = false;
+        }
+    },
+
+    getRenderTarget: function() {
+        return this.formTable;
+    },
+
+    getRenderTree: function() {
+        var me = this,
+            result = me.callParent(arguments),
+            i, len;
+
+        for (i = 0, len = result.length; i < len; i++) {
+            result[i] = me.transformItemRenderTree(result[i]);
+        }
+        return result;
+    },
+
+    transformItemRenderTree: function(item) {
+
+        if (item.tag && item.tag == 'table') {
+            item.tag = 'tbody';
+            delete item.cellspacing;
+            delete item.cellpadding;
+
+            
+            
+            
+            
+            if (Ext.isIE6) {
+                item.cn = this.padRow;
+            }
+
+            return item;
+        }
+
+        return {
+            tag: 'tbody',
+            cn: {
+                tag: 'tr',
+                cn: {
+                    tag: 'td',
+                    colspan: 3,
+                    style: 'width:100%',
+                    cn: item
+                }
+            }
+        };
+
+    },
+
+    isValidParent: function(item, target, position) {
+        return true;
+    },
+
+    isItemShrinkWrap: function(item) {
+        return ((item.shrinkWrap === true) ? 3 : item.shrinkWrap||0) & 2;
+    },
+
+    getItemSizePolicy: function(item) {
+        return {
+            setsWidth: 1,
+            setsHeight: 0
+        };
+    }
+});
+
+
+Ext.define('Ext.menu.Item', {
+    extend: 'Ext.Component',
+    alias: 'widget.menuitem',
+    alternateClassName: 'Ext.menu.TextItem',
+
+    
+
+    
+
+    
+    activeCls: Ext.baseCSSPrefix + 'menu-item-active',
+
+    
+    ariaRole: 'menuitem',
+
+    
+    canActivate: true,
+
+    
+    clickHideDelay: 1,
+
+    
+    destroyMenu: true,
+
+    
+    disabledCls: Ext.baseCSSPrefix + 'menu-item-disabled',
+
+    
+
+    
+
+    
+    hideOnClick: true,
+
+    
+
+    
+
+    isMenuItem: true,
+
+    
+
+    
+
+    
+    menuAlign: 'tl-tr?',
+
+    
+    menuExpandDelay: 200,
+
+    
+    menuHideDelay: 200,
+
+    
+
+    
+
+    
+    tooltipType: 'qtip',
+
+    arrowCls: Ext.baseCSSPrefix + 'menu-item-arrow',
+
+    childEls: [
+        'itemEl', 'iconEl', 'textEl', 'arrowEl'
+    ],
+
+    renderTpl: [
+        '<tpl if="plain">',
+            '{text}',
+        '<tpl else>',
+            '<a id="{id}-itemEl" class="' + Ext.baseCSSPrefix + 'menu-item-link" href="{href}" <tpl if="hrefTarget">target="{hrefTarget}"</tpl> hidefocus="true" unselectable="on">',
+                '<img id="{id}-iconEl" src="{icon}" class="' + Ext.baseCSSPrefix + 'menu-item-icon {iconCls}" />',
+                '<span id="{id}-textEl" class="' + Ext.baseCSSPrefix + 'menu-item-text" <tpl if="arrowCls">style="margin-right: 17px;"</tpl> >{text}</span>',
+                '<img id="{id}-arrowEl" src="{blank}" class="{arrowCls}" />',
+            '</a>',
+        '</tpl>'
+    ],
+
+    maskOnDisable: false,
+
+    
+
+    
+
+    activate: function() {
+        var me = this;
+
+        if (!me.activated && me.canActivate && me.rendered && !me.isDisabled() && me.isVisible()) {
+            me.el.addCls(me.activeCls);
+            me.focus();
+            me.activated = true;
+            me.fireEvent('activate', me);
+        }
+    },
+
+    getFocusEl: function() {
+        return this.itemEl;
+    },
+
+    deactivate: function() {
+        var me = this;
+
+        if (me.activated) {
+            me.el.removeCls(me.activeCls);
+            me.blur();
+            me.hideMenu();
+            me.activated = false;
+            me.fireEvent('deactivate', me);
+        }
+    },
+
+    deferExpandMenu: function() {
+        var me = this;
+
+        if (me.activated && (!me.menu.rendered || !me.menu.isVisible())) {
+            me.parentMenu.activeChild = me.menu;
+            me.menu.parentItem = me;
+            me.menu.parentMenu = me.menu.ownerCt = me.parentMenu;
+            me.menu.showBy(me, me.menuAlign);
+        }
+    },
+
+    deferHideMenu: function() {
+        if (this.menu.isVisible()) {
+            this.menu.hide();
+        }
+    },
+    
+    cancelDeferHide: function(){
+        clearTimeout(this.hideMenuTimer);
+    },
+
+    deferHideParentMenus: function() {
+        var ancestor;
+        Ext.menu.Manager.hideAll();
+
+        if (!Ext.Element.getActiveElement()) {
+            
+            ancestor = this.up(':not([hidden])');
+            if (ancestor) {
+                ancestor.focus();
+            }
+        }
+    },
+
+    expandMenu: function(delay) {
+        var me = this;
+
+        if (me.menu) {
+            me.cancelDeferHide();
+            if (delay === 0) {
+                me.deferExpandMenu();
+            } else {
+                me.expandMenuTimer = Ext.defer(me.deferExpandMenu, Ext.isNumber(delay) ? delay : me.menuExpandDelay, me);
+            }
+        }
+    },
+
+    getRefItems: function(deep){
+        var menu = this.menu,
+            items;
+
+        if (menu) {
+            items = menu.getRefItems(deep);
+            items.unshift(menu);
+        }
+        return items || [];
+    },
+
+    hideMenu: function(delay) {
+        var me = this;
+
+        if (me.menu) {
+            clearTimeout(me.expandMenuTimer);
+            me.hideMenuTimer = Ext.defer(me.deferHideMenu, Ext.isNumber(delay) ? delay : me.menuHideDelay, me);
+        }
+    },
+
+    initComponent: function() {
+        var me = this,
+            prefix = Ext.baseCSSPrefix,
+            cls = [prefix + 'menu-item'],
+            menu;
+
+        me.addEvents(
+            
+            'activate',
+
+            
+            'click',
+
+            
+            'deactivate'
+        );
+
+        if (me.plain) {
+            cls.push(prefix + 'menu-item-plain');
+        }
+
+        if (me.cls) {
+            cls.push(me.cls);
+        }
+
+        me.cls = cls.join(' ');
+
+        if (me.menu) {
+            menu = me.menu;
+            delete me.menu;
+            me.setMenu(menu);
+        }
+
+        me.callParent(arguments);
+    },
+
+    onClick: function(e) {
+        var me = this;
+
+        if (!me.href) {
+            e.stopEvent();
+        }
+
+        if (me.disabled) {
+            return;
+        }
+
+        if (me.hideOnClick) {
+            me.deferHideParentMenusTimer = Ext.defer(me.deferHideParentMenus, me.clickHideDelay, me);
+        }
+
+        Ext.callback(me.handler, me.scope || me, [me, e]);
+        me.fireEvent('click', me, e);
+
+        if (!me.hideOnClick) {
+            me.focus();
+        }
+    },
+
+    onRemoved: function() {
+        var me = this;
+
+        
+        if (me.activated && me.parentMenu.activeItem === me) {
+            me.parentMenu.deactivateActiveItem();
+        }
+        me.callParent(arguments);
+        delete me.parentMenu;
+        delete me.ownerButton;
+    },
+
+    
+    beforeDestroy: function() {
+        var me = this;
+        if (me.rendered) {
+            me.clearTip();
+        }
+        me.callParent();
+    },
+
+    onDestroy: function() {
+        var me = this;
+
+        clearTimeout(me.expandMenuTimer);
+        me.cancelDeferHide();
+        clearTimeout(me.deferHideParentMenusTimer);
+
+        me.setMenu(null);
+        me.callParent(arguments);
+    },
+
+    beforeRender: function() {
+        var me = this,
+            blank = Ext.BLANK_IMAGE_URL,
+            iconCls,
+            arrowCls;
+
+        me.callParent();
+
+        if (me.iconAlign === 'right') {
+            iconCls = me.checkChangeDisabled ? me.disabledCls : '';
+            arrowCls = Ext.baseCSSPrefix + 'menu-item-icon-right ' + me.iconCls;
+        } else {
+            iconCls = me.iconCls + (me.checkChangeDisabled ? ' ' + me.disabledCls : '');
+            arrowCls = me.menu ? me.arrowCls : '';
+        }
+        Ext.applyIf(me.renderData, {
+            href: me.href || '#',
+            hrefTarget: me.hrefTarget,
+            icon: me.icon || blank,
+            iconCls: iconCls,
+            plain: me.plain,
+            text: me.text,
+            arrowCls: arrowCls,
+            blank: blank
+        });
+    },
+
+    onRender: function() {
+        var me = this;
+
+        me.callParent(arguments);
+
+        if (me.tooltip) {
+            me.setTooltip(me.tooltip, true);
+        }
+    },
+    
+    
+    setMenu: function(menu, destroyMenu) {
+        var me = this,
+            oldMenu = me.menu,
+            arrowEl = me.arrowEl;
+            
+        if (oldMenu) {
+            delete oldMenu.parentItem;
+            delete oldMenu.parentMenu;
+            delete oldMenu.ownerCt;
+            delete oldMenu.ownerItem;
+            
+            if (destroyMenu === true || (destroyMenu !== false && me.destroyMenu)) {
+                Ext.destroy(oldMenu);
+            }
+        }
+        if (menu) {
+            me.menu = Ext.menu.Manager.get(menu);
+            me.menu.ownerItem = me;
+        } else {
+            me.menu = null;
+        }
+        
+        if (me.rendered && !me.destroying && arrowEl) {
+            arrowEl[me.menu ? 'addCls' : 'removeCls'](me.arrowCls);
+        }
+    },
+
+    
+    setHandler: function(fn, scope) {
+        this.handler = fn || null;
+        this.scope = scope;
+    },
+    
+    
+    setIcon: function(icon){
+        var iconEl = this.iconEl;
+        if (iconEl) {
+            iconEl.src = icon || Ext.BLANK_IMAGE_URL;
+        }
+        this.icon = icon;
+    },
+
+    
+    setIconCls: function(iconCls) {
+        var me = this,
+            iconEl = me.iconEl;
+
+        if (iconEl) {
+            if (me.iconCls) {
+                iconEl.removeCls(me.iconCls);
+            }
+
+            if (iconCls) {
+                iconEl.addCls(iconCls);
+            }
+        }
+
+        me.iconCls = iconCls;
+    },
+
+    
+    setText: function(text) {
+        var me = this,
+            el = me.textEl || me.el;
+
+        me.text = text;
+
+        if (me.rendered) {
+            el.update(text || '');
+            
+            me.ownerCt.updateLayout();
+        }
+    },
+
+    getTipAttr: function(){
+        return this.tooltipType == 'qtip' ? 'data-qtip' : 'title';
+    },
+
+    
+    clearTip: function() {
+        if (Ext.isObject(this.tooltip)) {
+            Ext.tip.QuickTipManager.unregister(this.itemEl);
+        }
+    },
+
+    
+    setTooltip: function(tooltip, initial) {
+        var me = this;
+
+        if (me.rendered) {
+            if (!initial) {
+                me.clearTip();
+            }
+
+            if (Ext.isObject(tooltip)) {
+                Ext.tip.QuickTipManager.register(Ext.apply({
+                    target: me.itemEl.id
+                },
+                tooltip));
+                me.tooltip = tooltip;
+            } else {
+                me.itemEl.dom.setAttribute(me.getTipAttr(), tooltip);
+            }
+        } else {
+            me.tooltip = tooltip;
+        }
+
+        return me;
+    }
+});
+
+
+Ext.define('Ext.menu.CheckItem', {
+    extend: 'Ext.menu.Item',
+    alias: 'widget.menucheckitem',
+    
+    
+    
+    
+
+    
+    
+    
+
+    
+    checkedCls: Ext.baseCSSPrefix + 'menu-item-checked',
+    
+    uncheckedCls: Ext.baseCSSPrefix + 'menu-item-unchecked',
+    
+    groupCls: Ext.baseCSSPrefix + 'menu-group-icon',
+
+    
+    hideOnClick: false,
+    
+    
+    checkChangeDisabled: false,
+
+    afterRender: function() {
+        var me = this;
+        me.callParent();
+        me.checked = !me.checked;
+        me.setChecked(!me.checked, true);
+        if (me.checkChangeDisabled) {
+            me.disableCheckChange();
+        }
+    },
+
+    initComponent: function() {
+        var me = this;
+        me.addEvents(
+            
+            'beforecheckchange',
+
+            
+            'checkchange'
+        );
+
+        me.callParent(arguments);
+
+        Ext.menu.Manager.registerCheckable(me);
+
+        if (me.group) {
+            if (!me.iconCls) {
+                me.iconCls = me.groupCls;
+            }
+            if (me.initialConfig.hideOnClick !== false) {
+                me.hideOnClick = true;
+            }
+        }
+    },
+
+    
+    disableCheckChange: function() {
+        var me = this,
+            iconEl = me.iconEl;
+
+        if (iconEl) {
+            iconEl.addCls(me.disabledCls);
+        }
+        
+        
+        if (!(Ext.isIE9 && Ext.isStrict) && me.rendered) {
+            me.el.repaint();
+        }
+        me.checkChangeDisabled = true;
+    },
+
+    
+    enableCheckChange: function() {
+        var me = this,
+            iconEl = me.iconEl;
+            
+        if (iconEl) {
+            iconEl.removeCls(me.disabledCls);
+        }
+        me.checkChangeDisabled = false;
+    },
+
+    onClick: function(e) {
+        var me = this;
+        if(!me.disabled && !me.checkChangeDisabled && !(me.checked && me.group)) {
+            me.setChecked(!me.checked);
+        }
+        this.callParent([e]);
+    },
+
+    onDestroy: function() {
+        Ext.menu.Manager.unregisterCheckable(this);
+        this.callParent(arguments);
+    },
+
+    
+    setChecked: function(checked, suppressEvents) {
+        var me = this;
+        if (me.checked !== checked && (suppressEvents || me.fireEvent('beforecheckchange', me, checked) !== false)) {
+            if (me.el) {
+                me.el[checked  ? 'addCls' : 'removeCls'](me.checkedCls)[!checked ? 'addCls' : 'removeCls'](me.uncheckedCls);
+            }
+            me.checked = checked;
+            Ext.menu.Manager.onCheckChange(me, checked);
+            if (!suppressEvents) {
+                Ext.callback(me.checkHandler, me.scope, [me, checked]);
+                me.fireEvent('checkchange', me, checked);
+            }
+        }
+    }
+});
+
+
+Ext.define('Ext.menu.KeyNav', {
+    extend: 'Ext.util.KeyNav',
+
+    requires: ['Ext.FocusManager'],
+    
+    constructor: function(menu) {
+        var me = this;
+
+        me.menu = menu;
+        me.callParent([menu.el, {
+            down: me.down,
+            enter: me.enter,
+            esc: me.escape,
+            left: me.left,
+            right: me.right,
+            space: me.enter,
+            tab: me.tab,
+            up: me.up
+        }]);
+    },
+
+    down: function(e) {
+        var me = this,
+            fi = me.menu.focusedItem;
+
+        if (fi && e.getKey() == Ext.EventObject.DOWN && me.isWhitelisted(fi)) {
+            return true;
+        }
+        me.focusNextItem(1);
+    },
+
+    enter: function(e) {
+        var menu = this.menu,
+            focused = menu.focusedItem;
+ 
+        if (menu.activeItem) {
+            menu.onClick(e);
+        } else if (focused && focused.isFormField) {
+            
+            return true;
+        }
+    },
+
+    escape: function(e) {
+        Ext.menu.Manager.hideAll();
+    },
+
+    focusNextItem: function(step) {
+        var menu = this.menu,
+            items = menu.items,
+            focusedItem = menu.focusedItem,
+            startIdx = focusedItem ? items.indexOf(focusedItem) : -1,
+            idx = startIdx + step,
+            item;
+
+        while (idx != startIdx) {
+            if (idx < 0) {
+                idx = items.length - 1;
+            } else if (idx >= items.length) {
+                idx = 0;
+            }
+
+            item = items.getAt(idx);
+            if (menu.canActivateItem(item)) {
+                menu.setActiveItem(item);
+                break;
+            }
+            idx += step;
+        }
+    },
+
+    isWhitelisted: function(item) {
+        return Ext.FocusManager.isWhitelisted(item);
+    },
+
+    left: function(e) {
+        var menu = this.menu,
+            fi = menu.focusedItem,
+            ai = menu.activeItem;
+
+        if (fi && this.isWhitelisted(fi)) {
+            return true;
+        }
+
+        menu.hide();
+        if (menu.parentMenu) {
+            menu.parentMenu.focus();
+        }
+    },
+
+    right: function(e) {
+        var menu = this.menu,
+            fi = menu.focusedItem,
+            ai = menu.activeItem,
+            am;
+
+        if (fi && this.isWhitelisted(fi)) {
+            return true;
+        }
+
+        if (ai) {
+            am = menu.activeItem.menu;
+            if (am) {
+                ai.expandMenu(0);
+                Ext.defer(function() {
+                    am.setActiveItem(am.items.getAt(0));
+                }, 25);
+            }
+        }
+    },
+
+    tab: function(e) {
+        var me = this;
+
+        if (e.shiftKey) {
+            me.up(e);
+        } else {
+            me.down(e);
+        }
+    },
+
+    up: function(e) {
+        var me = this,
+            fi = me.menu.focusedItem;
+
+        if (fi && e.getKey() == Ext.EventObject.UP && me.isWhitelisted(fi)) {
+            return true;
+        }
+        me.focusNextItem(-1);
+    }
+});
+
+
+Ext.define('Ext.menu.Separator', {
+    extend: 'Ext.menu.Item',
+    alias: 'widget.menuseparator',
+
+    
+
+    
+    canActivate: false,
+
+    
+
+    
+
+    
+
+    focusable: false,
+
+    
+
+    
+
+    
+    hideOnClick: false,
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+
+    
+    plain: true,
+
+    
+    separatorCls: Ext.baseCSSPrefix + 'menu-item-separator',
+
+    
+    text: '&#160;',
+
+    beforeRender: function(ct, pos) {
+        var me = this;
+
+        me.callParent();
+
+        me.addCls(me.separatorCls);
+    }
+});
+
+
+Ext.define('Ext.menu.Menu', {
+    extend: 'Ext.panel.Panel',
+    alias: 'widget.menu',
+    requires: [
+        'Ext.layout.container.Fit',
+        'Ext.layout.container.VBox',
+        'Ext.menu.CheckItem',
+        'Ext.menu.Item',
+        'Ext.menu.KeyNav',
+        'Ext.menu.Manager',
+        'Ext.menu.Separator'
+    ],
+
+    
+    
+    
+    enableKeyNav: true,
+
+    
+    allowOtherMenus: false,
+
+    
+    ariaRole: 'menu',
+
+    
+
+    
+    defaultAlign: 'tl-bl?',
+
+    
+    floating: true,
+
+    
+    constrain: true,
+
+    
+    hidden: true,
+
+    hideMode: 'visibility',
+
+    
+    ignoreParentClicks: false,
+
+    
+    isMenu: true,
+
+    
+
+    
+    showSeparator : true,
+
+    
+    minWidth: undefined,
+    
+    defaultMinWidth: 120,
+
+    
+
+    initComponent: function() {
+        var me = this,
+            prefix = Ext.baseCSSPrefix,
+            cls = [prefix + 'menu'],
+            bodyCls = me.bodyCls ? [me.bodyCls] : [],
+            isFloating = me.floating !== false;
+
+        me.addEvents(
+            
+            'click',
+
+            
+            'mouseenter',
+
+            
+            'mouseleave',
+
+            
+            'mouseover'
+        );
+
+        Ext.menu.Manager.register(me);
+
+        
+        if (me.plain) {
+            cls.push(prefix + 'menu-plain');
+        }
+        me.cls = cls.join(' ');
+
+        
+        bodyCls.unshift(prefix + 'menu-body');
+        me.bodyCls = bodyCls.join(' ');
+
+        
+        
+        
+        
+        if (!me.layout) {
+            me.layout = {
+                type: 'vbox',
+                align: 'stretchmax',
+                overflowHandler: 'Scroller'
+            };
+        }
+        
+        
+        if (isFloating && me.minWidth === undefined) {
+            me.minWidth = me.defaultMinWidth;
+        }
+
+        
+        if (!isFloating && me.initialConfig.hidden !== true) {
+            me.hidden = false;
+        }
+
+        me.callParent(arguments);
+
+        me.on('beforeshow', function() {
+            var hasItems = !!me.items.length;
+            
+            
+            
+            if (hasItems && me.rendered) {
+                me.el.setStyle('visibility', null);
+            }
+            return hasItems;
+        });
+    },
+
+    beforeRender: function() {
+        this.callParent(arguments);
+
+        
+        
+        if (!this.getSizeModel().width.shrinkWrap) {
+            this.layout.align = 'stretch';
+        }
+    },
+
+    onBoxReady: function() {
+        var me = this,
+            separatorSpec;
+
+        me.callParent(arguments);
+
+        
+        if (me.showSeparator) {
+            separatorSpec = {
+                cls: Ext.baseCSSPrefix + 'menu-icon-separator',
+                html: '&#160;'
+            };
+            if ((!Ext.isStrict && Ext.isIE) || Ext.isIE6) {
+                separatorSpec.style = 'height:' + me.el.getHeight() + 'px';
+            }
+            me.iconSepEl = me.layout.getElementTarget().insertFirst(separatorSpec);
+        }
+
+        me.mon(me.el, {
+            click: me.onClick,
+            mouseover: me.onMouseOver,
+            scope: me
+        });
+        me.mouseMonitor = me.el.monitorMouseLeave(100, me.onMouseLeave, me);
+
+        if (me.enableKeyNav) {
+            me.keyNav = new Ext.menu.KeyNav(me);
+        }
+    },
+
+    getBubbleTarget: function() {
+        
+        
+        
+        return this.parentMenu || this.ownerButton || this.callParent(arguments);
+    },
+
+    
+    canActivateItem: function(item) {
+        return item && !item.isDisabled() && item.isVisible() && (item.canActivate || item.getXTypes().indexOf('menuitem') < 0);
+    },
+
+    
+    deactivateActiveItem: function(andBlurFocusedItem) {
+        var me = this,
+            activeItem = me.activeItem,
+            focusedItem = me.focusedItem;
+
+        if (activeItem) {
+            activeItem.deactivate();
+            if (!activeItem.activated) {
+                delete me.activeItem;
+            }
+        }
+
+        
+        
+        if (focusedItem && andBlurFocusedItem) {
+            focusedItem.blur();
+            delete me.focusedItem;
+        }
+    },
+
+    
+    getFocusEl: function() {
+        return this.focusedItem || this.el;
+    },
+
+    
+    hide: function() {
+        this.deactivateActiveItem(true);
+        this.callParent(arguments);
+    },
+
+    
+    getItemFromEvent: function(e) {
+        return this.getChildByElement(e.getTarget());
+    },
+
+    lookupComponent: function(cmp) {
+        var me = this;
+
+        if (typeof cmp == 'string') {
+            cmp = me.lookupItemFromString(cmp);
+        } else if (Ext.isObject(cmp)) {
+            cmp = me.lookupItemFromObject(cmp);
+        }
+
+        
+        
+        cmp.minWidth = cmp.minWidth || me.minWidth;
+
+        return cmp;
+    },
+
+    
+    lookupItemFromObject: function(cmp) {
+        var me = this,
+            prefix = Ext.baseCSSPrefix,
+            cls;
+
+        if (!cmp.isComponent) {
+            if (!cmp.xtype) {
+                cmp = Ext.create('Ext.menu.' + (Ext.isBoolean(cmp.checked) ? 'Check': '') + 'Item', cmp);
+            } else {
+                cmp = Ext.ComponentManager.create(cmp, cmp.xtype);
+            }
+        }
+
+        if (cmp.isMenuItem) {
+            cmp.parentMenu = me;
+        }
+
+        if (!cmp.isMenuItem && !cmp.dock) {
+            cls = [prefix + 'menu-item', prefix + 'menu-item-cmp'];
+
+            if (!me.plain && (cmp.indent === true || cmp.iconCls === 'no-icon')) {
+                cls.push(prefix + 'menu-item-indent');
+            }
+
+            if (cmp.rendered) {
+                cmp.el.addCls(cls);
+            } else {
+                cmp.cls = (cmp.cls ? cmp.cls : '') + ' ' + cls.join(' ');
+            }
+        }
+        return cmp;
+    },
+
+    
+    lookupItemFromString: function(cmp) {
+        return (cmp == 'separator' || cmp == '-') ?
+            new Ext.menu.Separator()
+            : new Ext.menu.Item({
+                canActivate: false,
+                hideOnClick: false,
+                plain: true,
+                text: cmp
+            });
+    },
+
+    onClick: function(e) {
+        var me = this,
+            item;
+
+        if (me.disabled) {
+            e.stopEvent();
+            return;
+        }
+
+        item = (e.type === 'click') ? me.getItemFromEvent(e) : me.activeItem;
+        if (item && item.isMenuItem) {
+            if (!item.menu || !me.ignoreParentClicks) {
+                item.onClick(e);
+            } else {
+                e.stopEvent();
+            }
+        }
+        
+        if (!item || item.disabled) {
+            item = undefined;
+        }
+        me.fireEvent('click', me, item, e);
+    },
+
+    onDestroy: function() {
+        var me = this;
+
+        Ext.menu.Manager.unregister(me);
+        delete me.parentMenu;
+        delete me.ownerButton;
+        if (me.rendered) {
+            me.el.un(me.mouseMonitor);
+            Ext.destroy(me.keyNav);
+            delete me.keyNav;
+        }
+        me.callParent(arguments);
+    },
+
+    onMouseLeave: function(e) {
+        var me = this;
+
+        me.deactivateActiveItem();
+
+        if (me.disabled) {
+            return;
+        }
+
+        me.fireEvent('mouseleave', me, e);
+    },
+
+    onMouseOver: function(e) {
+        var me = this,
+            fromEl = e.getRelatedTarget(),
+            mouseEnter = !me.el.contains(fromEl),
+            item = me.getItemFromEvent(e),
+            parentMenu = me.parentMenu,
+            parentItem = me.parentItem;
+
+        if (mouseEnter && parentMenu) {
+            parentMenu.setActiveItem(parentItem);
+            parentItem.cancelDeferHide();
+            parentMenu.mouseMonitor.mouseenter();
+        }
+
+        if (me.disabled) {
+            return;
+        }
+
+        
+        if (item && !item.activated) {
+            me.setActiveItem(item);
+            if (item.activated && item.expandMenu) {
+                item.expandMenu();
+            }
+        }
+        if (mouseEnter) {
+            me.fireEvent('mouseenter', me, e);
+        }
+        me.fireEvent('mouseover', me, item, e);
+    },
+
+    setActiveItem: function(item) {
+        var me = this;
+
+        if (item && (item != me.activeItem)) {
+            me.deactivateActiveItem();
+            if (me.canActivateItem(item)) {
+                if (item.activate) {
+                    item.activate();
+                    if (item.activated) {
+                        me.activeItem = item;
+                        me.focusedItem = item;
+                        me.focus();
+                    }
+                } else {
+                    item.focus();
+                    me.focusedItem = item;
+                }
+            }
+            item.el.scrollIntoView(me.layout.getRenderTarget());
+        }
+    },
+
+    
+    showBy: function(cmp, pos, off) {
+        var me = this;
+
+        if (me.floating && cmp) {
+            me.show();
+
+            
+            
+            
+            me.setPagePosition(me.el.getAlignToXY(cmp.el || cmp, pos || me.defaultAlign, off));
+            me.setVerticalPosition();
+        }
+        return me;
+    },
+
+    show: function() {
+        var me = this,
+            parentEl, viewHeight, result,
+            maxWas = me.maxHeight;
+
+        
+        if (!me.rendered){
+            me.doAutoRender();
+        }
+
+        
+        if (me.floating) {
+            
+            parentEl = Ext.fly(me.el.getScopeParent());
+            viewHeight = parentEl.getViewSize().height;
+            me.maxHeight  =  Math.min(maxWas || viewHeight, viewHeight);
+        }
+
+        result = me.callParent(arguments);
+        me.maxHeight = maxWas;
+        return result;
+    },
+
+    afterComponentLayout: function(width, height, oldWidth, oldHeight){
+        var me = this;
+        me.callParent(arguments);
+        
+        if (me.showSeparator){
+            me.iconSepEl.setHeight(me.componentLayout.lastComponentSize.contentHeight);
+        }
+    },
+
+    
+    
+    
+    setVerticalPosition: function(){
+        var me = this,
+            max,
+            y = me.el.getY(),
+            returnY = y,
+            height = me.getHeight(),
+            viewportHeight = Ext.Element.getViewportHeight().height,
+            parentEl = Ext.fly(me.el.getScopeParent()),
+            viewHeight = parentEl.getViewSize().height,
+            normalY = y - parentEl.getScroll().top; 
+
+        parentEl = null;
+
+        if (me.floating) {
+            max = me.maxHeight ? me.maxHeight : viewHeight - normalY;
+            if (height > viewHeight) {
+                returnY = y - normalY;
+            } else if (max < height) {
+                returnY = y - (height - max);
+            } else if((y + height) > viewportHeight){ 
+                returnY = viewportHeight - height;
+            }
+        }
+        me.el.setY(returnY);
+    }
+});
+
+
+ Ext.define('Ext.menu.ColorPicker', {
+     extend: 'Ext.menu.Menu',
+
+     alias: 'widget.colormenu',
+
+     requires: [
+        'Ext.picker.Color'
+     ],
+
+    
+    hideOnClick : true,
+
+    
+    pickerId : null,
+
+    
+
+    
+
+    
+
+    initComponent : function(){
+        var me = this,
+            cfg = Ext.apply({}, me.initialConfig);
+
+        
+        delete cfg.listeners;
+        Ext.apply(me, {
+            plain: true,
+            showSeparator: false,
+            items: Ext.applyIf({
+                cls: Ext.baseCSSPrefix + 'menu-color-item',
+                id: me.pickerId,
+                xtype: 'colorpicker'
+            }, cfg)
+        });
+
+        me.callParent(arguments);
+
+        me.picker = me.down('colorpicker');
+
+        
+        me.relayEvents(me.picker, ['select']);
+
+        if (me.hideOnClick) {
+            me.on('select', me.hidePickerOnSelect, me);
+        }
+    },
+
+    
+    hidePickerOnSelect: function() {
+        Ext.menu.Manager.hideAll();
+    }
+ });
+
+
+ Ext.define('Ext.menu.DatePicker', {
+     extend: 'Ext.menu.Menu',
+
+     alias: 'widget.datemenu',
+
+     requires: [
+        'Ext.picker.Date'
+     ],
+
+    
+    hideOnClick : true,
+
+    
+    pickerId : null,
+
+    
+
+    
+
+    initComponent : function(){
+        var me = this,
+            cfg = Ext.apply({}, me.initialConfig);
+            
+        
+        delete cfg.listeners;
+            
+        Ext.apply(me, {
+            showSeparator: false,
+            plain: true,
+            border: false,
+            bodyPadding: 0, 
+            items: Ext.applyIf({
+                cls: Ext.baseCSSPrefix + 'menu-date-item',
+                id: me.pickerId,
+                xtype: 'datepicker'
+            }, cfg)
+        });
+
+        me.callParent(arguments);
+
+        me.picker = me.down('datepicker');
+        
+        me.relayEvents(me.picker, ['select']);
+
+        if (me.hideOnClick) {
+            me.on('select', me.hidePickerOnSelect, me);
+        }
+    },
+
+    hidePickerOnSelect: function() {
+        Ext.menu.Manager.hideAll();
+    }
+ });
+
+
+Ext.define('Ext.panel.Tool', {
+    extend: 'Ext.Component',
+    requires: ['Ext.tip.QuickTipManager'],
+    alias: 'widget.tool',
+
+    baseCls: Ext.baseCSSPrefix + 'tool',
+    disabledCls: Ext.baseCSSPrefix + 'tool-disabled',
+    
+    
+    toolPressedCls: Ext.baseCSSPrefix + 'tool-pressed',
+    
+    toolOverCls: Ext.baseCSSPrefix + 'tool-over',
+
+    ariaRole: 'button',
+
+    childEls: [
+        'toolEl'
+    ],
+
+    renderTpl: [
+        '<img id="{id}-toolEl" src="{blank}" class="{baseCls}-{type}" role="presentation"/>'
+    ],
+
+    
+
+    
+
+    
+
+    
+
+     
+    tooltipType: 'qtip',
+
+    
+    stopEvent: true,
+    
+    height: 15,
+    width: 15,
+
+
+    initComponent: function() {
+        var me = this;
+        me.addEvents(
+            
+            'click'
+        );
+
+
+        me.type = me.type || me.id;
+
+        Ext.applyIf(me.renderData, {
+            baseCls: me.baseCls,
+            blank: Ext.BLANK_IMAGE_URL,
+            type: me.type
+        });
+
+        
+        me.tooltip = me.tooltip || me.qtip;
+        me.callParent();
+        me.on({
+            element: 'toolEl',
+            click: me.onClick,
+            mousedown: me.onMouseDown,
+            mouseover: me.onMouseOver,
+            mouseout: me.onMouseOut,
+            scope: me
+        });
+    },
+
+    
+    afterRender: function() {
+        var me = this,
+            attr;
+
+        me.callParent(arguments);
+        if (me.tooltip) {
+            if (Ext.isObject(me.tooltip)) {
+                Ext.tip.QuickTipManager.register(Ext.apply({
+                    target: me.id
+                }, me.tooltip));
+            }
+            else {
+                attr = me.tooltipType == 'qtip' ? 'data-qtip' : 'title';
+                me.toolEl.dom.setAttribute(attr, me.tooltip);
+            }
+        }
+    },
+
+    getFocusEl: function() {
+        return this.el;
+    },
+
+    
+    setType: function(type) {
+        var me = this;
+
+        me.type = type;
+        if (me.rendered) {
+            me.toolEl.dom.className = me.baseCls + '-' + type;
+        }
+        return me;
+    },
+
+    
+    bindTo: function(component) {
+        this.owner = component;
+    },
+
+    
+    onClick: function(e, target) {
+        var me = this,
+            owner;
+
+        if (me.disabled) {
+            return false;
+        }
+        owner = me.owner || me.ownerCt;
+
+        
+        me.el.removeCls(me.toolPressedCls);
+        me.el.removeCls(me.toolOverCls);
+
+        if (me.stopEvent !== false) {
+            e.stopEvent();
+        }
+
+        Ext.callback(me.handler, me.scope || me, [e, target, owner, me]);
+        me.fireEvent('click', me, e);
+        return true;
+    },
+
+    
+    onDestroy: function(){
+        if (Ext.isObject(this.tooltip)) {
+            Ext.tip.QuickTipManager.unregister(this.id);
+        }
+        this.callParent();
+    },
+
+    
+    onMouseDown: function() {
+        if (this.disabled) {
+            return false;
+        }
+
+        this.el.addCls(this.toolPressedCls);
+    },
+
+    
+    onMouseOver: function() {
+        if (this.disabled) {
+            return false;
+        }
+        this.el.addCls(this.toolOverCls);
+    },
+
+    
+    onMouseOut: function() {
+        this.el.removeCls(this.toolOverCls);
+    }
+});
+
+
+Ext.define('Ext.resizer.SplitterTracker', {
+    extend: 'Ext.dd.DragTracker',
+    requires: ['Ext.util.Region'],
+    enabled: true,
+    
+    overlayCls: Ext.baseCSSPrefix + 'resizable-overlay',
+
+    createDragOverlay: function () {
+        var overlay;
+
+        overlay = this.overlay =  Ext.getBody().createChild({
+            cls: this.overlayCls, 
+            html: '&#160;'
+        });
+
+        overlay.unselectable();
+        overlay.setSize(Ext.Element.getViewWidth(true), Ext.Element.getViewHeight(true));
+        overlay.show();
+    },
+
+    getPrevCmp: function() {
+        var splitter = this.getSplitter();
+        return splitter.previousSibling();
+    },
+
+    getNextCmp: function() {
+        var splitter = this.getSplitter();
+        return splitter.nextSibling();
+    },
+
+    
+    
+    onBeforeStart: function(e) {
+        var me = this,
+            prevCmp = me.getPrevCmp(),
+            nextCmp = me.getNextCmp(),
+            collapseEl = me.getSplitter().collapseEl,
+            target = e.getTarget(),
+            box;
+
+        if (collapseEl && target === me.getSplitter().collapseEl.dom) {
+            return false;
+        }
+
+        
+        if (nextCmp.collapsed || prevCmp.collapsed) {
+            return false;
+        }
+
+        
+        me.prevBox  = prevCmp.getEl().getBox();
+        me.nextBox  = nextCmp.getEl().getBox();
+        me.constrainTo = box = me.calculateConstrainRegion();
+
+        if (!box) {
+            return false;
+        }
+
+        me.createDragOverlay();
+
+        return box;
+    },
+
+    
+    onStart: function(e) {
+        var splitter = this.getSplitter();
+        splitter.addCls(splitter.baseCls + '-active');
+    },
+
+    
+    calculateConstrainRegion: function() {
+        var me         = this,
+            splitter   = me.getSplitter(),
+            splitWidth = splitter.getWidth(),
+            defaultMin = splitter.defaultSplitMin,
+            orient     = splitter.orientation,
+            prevBox    = me.prevBox,
+            prevCmp    = me.getPrevCmp(),
+            nextBox    = me.nextBox,
+            nextCmp    = me.getNextCmp(),
+            
+            
+            
+            prevConstrainRegion, nextConstrainRegion;
+
+        
+        if (orient === 'vertical') {
+
+            
+            
+            prevConstrainRegion = new Ext.util.Region(
+                prevBox.y,
+                
+                
+                (prevCmp.maxWidth ? prevBox.x + prevCmp.maxWidth : nextBox.right - (nextCmp.minWidth || defaultMin)) + splitWidth,
+                prevBox.bottom,
+                prevBox.x + (prevCmp.minWidth || defaultMin)
+            );
+            
+            nextConstrainRegion = new Ext.util.Region(
+                nextBox.y,
+                nextBox.right - (nextCmp.minWidth || defaultMin),
+                nextBox.bottom,
+                
+                
+                (nextCmp.maxWidth ? nextBox.right - nextCmp.maxWidth : prevBox.x + (prevBox.minWidth || defaultMin)) - splitWidth
+            );
+        } else {
+            
+            prevConstrainRegion = new Ext.util.Region(
+                prevBox.y + (prevCmp.minHeight || defaultMin),
+                prevBox.right,
+                
+                
+                (prevCmp.maxHeight ? prevBox.y + prevCmp.maxHeight : nextBox.bottom - (nextCmp.minHeight || defaultMin)) + splitWidth,
+                prevBox.x
+            );
+            
+            nextConstrainRegion = new Ext.util.Region(
+                
+                
+                (nextCmp.maxHeight ? nextBox.bottom - nextCmp.maxHeight : prevBox.y + (prevCmp.minHeight || defaultMin)) - splitWidth,
+                nextBox.right,
+                nextBox.bottom - (nextCmp.minHeight || defaultMin),
+                nextBox.x
+            );
+        }
+
+        
+        return prevConstrainRegion.intersect(nextConstrainRegion);
+    },
+
+    
+    performResize: function(e, offset) {
+        var me        = this,
+            splitter  = me.getSplitter(),
+            orient    = splitter.orientation,
+            prevCmp   = me.getPrevCmp(),
+            nextCmp   = me.getNextCmp(),
+            owner     = splitter.ownerCt,
+            flexedSiblings = owner.query('>[flex]'),
+            len       = flexedSiblings.length,
+            i         = 0,
+            dimension,
+            size,
+            totalFlex = 0;
+
+        
+        for (; i < len; i++) {
+            size = flexedSiblings[i].getWidth();
+            totalFlex += size;
+            flexedSiblings[i].flex = size;
+        }
+
+        offset = offset || me.getOffset('dragTarget');
+
+        if (orient === 'vertical') {
+            offset = offset[0];
+            dimension = 'width';
+        } else {
+            dimension = 'height';
+            offset = offset[1];
+        }
+        if (prevCmp) {
+            size = me.prevBox[dimension] + offset;
+            if (prevCmp.flex) {
+                prevCmp.flex = size;
+            } else {
+                prevCmp[dimension] = size;
+            }
+        }
+        if (nextCmp) {
+            size = me.nextBox[dimension] - offset;
+            if (nextCmp.flex) {
+                nextCmp.flex = size;
+            } else {
+                nextCmp[dimension] = size;
+            }
+        }
+
+        owner.updateLayout();
+    },
+
+    
+    
+    
+    endDrag: function () {
+        var me = this;
+
+        if (me.overlay) {
+             me.overlay.remove();
+             delete me.overlay;
+        }
+
+        me.callParent(arguments); 
+    },
+
+    
+    onEnd: function(e) {
+        var me = this,
+            splitter = me.getSplitter();
+            
+        splitter.removeCls(splitter.baseCls + '-active');
+        me.performResize(e, me.getOffset('dragTarget'));
+    },
+
+    
+    
+    onDrag: function(e) {
+        var me        = this,
+            offset    = me.getOffset('dragTarget'),
+            splitter  = me.getSplitter(),
+            splitEl   = splitter.getEl(),
+            orient    = splitter.orientation;
+
+        if (orient === "vertical") {
+            splitEl.setX(me.startRegion.left + offset[0]);
+        } else {
+            splitEl.setY(me.startRegion.top + offset[1]);
+        }
+    },
+
+    getSplitter: function() {
+        return this.splitter;
+    }
+});
+
+
+Ext.define('Ext.resizer.BorderSplitterTracker', {
+    extend: 'Ext.resizer.SplitterTracker',
+    requires: ['Ext.util.Region'],
+
+    getPrevCmp: null,
+    getNextCmp: null,
+
+    
+    calculateConstrainRegion: function() {
+        var me = this,
+            splitter = me.splitter,
+            collapseTarget = splitter.collapseTarget,
+            defaultSplitMin = splitter.defaultSplitMin,
+            sizePropCap = splitter.vertical ? 'Width' : 'Height',
+            minSizeProp = 'min' + sizePropCap,
+            maxSizeProp = 'max' + sizePropCap,
+            getSizeMethod = 'get' + sizePropCap,
+            neighbors = splitter.neighbors,
+            length = neighbors.length,
+            box = collapseTarget.el.getBox(),
+            left = box.x,
+            top = box.y,
+            right = box.right,
+            bottom = box.bottom,
+            size = splitter.vertical ? (right - left) : (bottom - top),
+            
+            i, neighbor, minRange, maxRange, maxGrowth, maxShrink, targetSize;
+
+        
+        minRange = (collapseTarget[minSizeProp] || Math.min(size,defaultSplitMin)) - size;
+
+        
+        maxRange = collapseTarget[maxSizeProp];
+        if (!maxRange) {
+            maxRange = 1e9;
+        } else {
+            maxRange -= size;
+        }
+        targetSize = size;
+
+        for (i = 0; i < length; ++i) {
+            neighbor = neighbors[i];
+            size = neighbor[getSizeMethod]();
+            
+
+            maxGrowth = size - neighbor[maxSizeProp]; 
+            maxShrink = size - (neighbor[minSizeProp] || Math.min(size,defaultSplitMin));
+
+            if (!isNaN(maxGrowth)) {
+                
+                
+                if (minRange < maxGrowth) {
+                    minRange = maxGrowth;
+                }
+            }
+
+            
+            
+            if (maxRange > maxShrink) {
+                maxRange = maxShrink;
+            }
+        }
+
+        if (maxRange - minRange < 2) {
+            return null;
+        }
+
+        box = new Ext.util.Region(top, right, bottom, left);
+
+        me.constraintAdjusters[splitter.collapseDirection](box, minRange, maxRange, splitter);
+
+        me.dragInfo = {
+            minRange: minRange,
+            maxRange: maxRange,
+            
+            targetSize: targetSize
+        };
+
+        return box;
+    },
+
+    constraintAdjusters: {
+        
+        left: function (box, minRange, maxRange, splitter) {
+            box[0] = box.x = box.left = box.right + minRange;
+            box.right += maxRange + splitter.getWidth();
+        },
+
+        
+        top: function (box, minRange, maxRange, splitter) {
+            box[1] = box.y = box.top = box.bottom + minRange;
+            box.bottom += maxRange + splitter.getHeight();
+        },
+
+        
+        bottom: function (box, minRange, maxRange, splitter) {
+            box.bottom = box.top - minRange;
+            box.top -= maxRange + splitter.getHeight();
+        },
+
+        
+        right: function (box, minRange, maxRange, splitter) {
+            box.right = box.left - minRange;
+            box.left -= maxRange + splitter.getWidth();
+        }
+    },
+
+    onBeforeStart: function(e) {
+        var me = this,
+            splitter = me.splitter,
+            collapseTarget = splitter.collapseTarget,
+            neighbors = splitter.neighbors,
+            collapseEl = me.getSplitter().collapseEl,
+            target = e.getTarget(),
+            length = neighbors.length,
+            i, neighbor;
+            
+        if (collapseEl && target === splitter.collapseEl.dom) {
+            return false;
+        }
+
+        if (collapseTarget.collapsed) {
+            return false;
+        }
+
+        
+        for (i = 0; i < length; ++i) {
+            neighbor = neighbors[i];
+
+            if (neighbor.collapsed && neighbor.isHorz === collapseTarget.isHorz) {
+                return false;
+            }
+        }
+
+        if (!(me.constrainTo = me.calculateConstrainRegion())) {
+            return false;
+        }
+
+        me.createDragOverlay();
+        return true;
+    },
+
+    performResize: function(e, offset) {
+        var me = this,
+            splitter = me.splitter,
+            collapseDirection = splitter.collapseDirection,
+            collapseTarget = splitter.collapseTarget,
+            
+            adjusters = me.splitAdjusters[splitter.vertical ? 'horz' : 'vert'],
+            delta = offset[adjusters.index],
+            dragInfo = me.dragInfo,
+            
+            
+            
+            
+            
+            owner;
+
+        if (collapseDirection == 'right' || collapseDirection == 'bottom') {
+            
+            delta = -delta;
+        }
+
+        
+        delta = Math.min(Math.max(dragInfo.minRange, delta), dragInfo.maxRange);
+
+        if (delta) {
+            (owner = splitter.ownerCt).suspendLayouts();
+
+            adjusters.adjustTarget(collapseTarget, dragInfo.targetSize, delta);
+
+            
+            
+            
+            
+            
+            
+            
+
+            owner.resumeLayouts(true);
+        }
+    },
+
+    splitAdjusters: {
+        horz: {
+            index: 0,
+            
+            
+            
+            adjustTarget: function (target, size, delta) {
+                target.flex = null;
+                target.setSize(size + delta);
+            }
+        },
+        vert: {
+            index: 1,
+            
+            
+            
+            adjustTarget: function (target, targetSize, delta) {
+                target.flex = null;
+                target.setSize(undefined, targetSize + delta);
+            }
+        }
+    }
+});
+
+
+Ext.define('Ext.resizer.Handle', {
+    extend: 'Ext.Component',
+    handleCls: '',
+    baseHandleCls: Ext.baseCSSPrefix + 'resizable-handle',
+    
+    
+    region: '',
+
+    beforeRender: function() {
+        var me = this;
+
+        me.callParent();
+
+        me.addCls(
+            me.baseHandleCls,
+            me.baseHandleCls + '-' + me.region,
+            me.handleCls
+        );
+    },
+
+    onRender: function() {
+        this.callParent(arguments);
+
+        this.el.unselectable();
+    }
+});
+
+
+Ext.define('Ext.resizer.ResizeTracker', {
+    extend: 'Ext.dd.DragTracker',
+    dynamic: true,
+    preserveRatio: false,
+
+    
+    constrainTo: null,
+    
+    proxyCls:  Ext.baseCSSPrefix + 'resizable-proxy',
+
+    constructor: function(config) {
+        var me = this,
+            widthRatio, heightRatio,
+            throttledResizeFn;
+
+        if (!config.el) {
+            if (config.target.isComponent) {
+                me.el = config.target.getEl();
+            } else {
+                me.el = config.target;
+            }
+        }
+        this.callParent(arguments);
+
+        
+        if (me.preserveRatio && me.minWidth && me.minHeight) {
+            widthRatio = me.minWidth / me.el.getWidth();
+            heightRatio = me.minHeight / me.el.getHeight();
+
+            
+            
+            
+            if (heightRatio > widthRatio) {
+                me.minWidth = me.el.getWidth() * heightRatio;
+            } else {
+                me.minHeight = me.el.getHeight() * widthRatio;
+            }
+        }
+
+        
+        
+        if (me.throttle) {
+            throttledResizeFn = Ext.Function.createThrottled(function() {
+                    Ext.resizer.ResizeTracker.prototype.resize.apply(me, arguments);
+                }, me.throttle);
+
+            me.resize = function(box, direction, atEnd) {
+                if (atEnd) {
+                    Ext.resizer.ResizeTracker.prototype.resize.apply(me, arguments);
+                } else {
+                    throttledResizeFn.apply(null, arguments);
+                }
+            };
+        }
+    },
+
+    onBeforeStart: function(e) {
+        
+        this.startBox = this.el.getBox();
+    },
+
+    
+    getDynamicTarget: function() {
+        var me = this,
+            target = me.target;
+            
+        if (me.dynamic) {
+            return target;
+        } else if (!me.proxy) {
+            me.proxy = me.createProxy(target);
+        }
+        me.proxy.show();
+        return me.proxy;
+    },
+    
+    
+    createProxy: function(target){
+        var proxy,
+            cls = this.proxyCls,
+            renderTo;
+            
+        if (target.isComponent) {
+            proxy = target.getProxy().addCls(cls);
+        } else {
+            renderTo = Ext.getBody();
+            if (Ext.scopeResetCSS) {
+                renderTo = Ext.getBody().createChild({
+                    cls: Ext.resetCls
+                });
+            }
+            proxy = target.createProxy({
+                tag: 'div',
+                cls: cls,
+                id: target.id + '-rzproxy'
+            }, renderTo);
+        }
+        proxy.removeCls(Ext.baseCSSPrefix + 'proxy-el');
+        return proxy;
+    },
+
+    onStart: function(e) {
+        
+        this.activeResizeHandle = Ext.get(this.getDragTarget().id);
+
+        
+        if (!this.dynamic) {
+            this.resize(this.startBox, {
+                horizontal: 'none',
+                vertical: 'none'
+            });
+        }
+    },
+
+    onDrag: function(e) {
+        
+        if (this.dynamic || this.proxy) {
+            this.updateDimensions(e);
+        }
+    },
+
+    updateDimensions: function(e, atEnd) {
+        var me = this,
+            region = me.activeResizeHandle.region,
+            offset = me.getOffset(me.constrainTo ? 'dragTarget' : null),
+            box = me.startBox,
+            ratio,
+            widthAdjust = 0,
+            heightAdjust = 0,
+            snappedWidth,
+            snappedHeight,
+            adjustX = 0,
+            adjustY = 0,
+            dragRatio,
+            horizDir = offset[0] < 0 ? 'right' : 'left',
+            vertDir = offset[1] < 0 ? 'down' : 'up',
+            oppositeCorner,
+            axis, 
+            newBox,
+            newHeight, newWidth;
+
+        switch (region) {
+            case 'south':
+                heightAdjust = offset[1];
+                axis = 2;
+                break;
+            case 'north':
+                heightAdjust = -offset[1];
+                adjustY = -heightAdjust;
+                axis = 2;
+                break;
+            case 'east':
+                widthAdjust = offset[0];
+                axis = 1;
+                break;
+            case 'west':
+                widthAdjust = -offset[0];
+                adjustX = -widthAdjust;
+                axis = 1;
+                break;
+            case 'northeast':
+                heightAdjust = -offset[1];
+                adjustY = -heightAdjust;
+                widthAdjust = offset[0];
+                oppositeCorner = [box.x, box.y + box.height];
+                axis = 3;
+                break;
+            case 'southeast':
+                heightAdjust = offset[1];
+                widthAdjust = offset[0];
+                oppositeCorner = [box.x, box.y];
+                axis = 3;
+                break;
+            case 'southwest':
+                widthAdjust = -offset[0];
+                adjustX = -widthAdjust;
+                heightAdjust = offset[1];
+                oppositeCorner = [box.x + box.width, box.y];
+                axis = 3;
+                break;
+            case 'northwest':
+                heightAdjust = -offset[1];
+                adjustY = -heightAdjust;
+                widthAdjust = -offset[0];
+                adjustX = -widthAdjust;
+                oppositeCorner = [box.x + box.width, box.y + box.height];
+                axis = 3;
+                break;
+        }
+
+        newBox = {
+            width: box.width + widthAdjust,
+            height: box.height + heightAdjust,
+            x: box.x + adjustX,
+            y: box.y + adjustY
+        };
+
+        
+        snappedWidth = Ext.Number.snap(newBox.width, me.widthIncrement);
+        snappedHeight = Ext.Number.snap(newBox.height, me.heightIncrement);
+        if (snappedWidth != newBox.width || snappedHeight != newBox.height){
+            switch (region) {
+                case 'northeast':
+                    newBox.y -= snappedHeight - newBox.height;
+                    break;
+                case 'north':
+                    newBox.y -= snappedHeight - newBox.height;
+                    break;
+                case 'southwest':
+                    newBox.x -= snappedWidth - newBox.width;
+                    break;
+                case 'west':
+                    newBox.x -= snappedWidth - newBox.width;
+                    break;
+                case 'northwest':
+                    newBox.x -= snappedWidth - newBox.width;
+                    newBox.y -= snappedHeight - newBox.height;
+            }
+            newBox.width = snappedWidth;
+            newBox.height = snappedHeight;
+        }
+
+        
+        if (newBox.width < me.minWidth || newBox.width > me.maxWidth) {
+            newBox.width = Ext.Number.constrain(newBox.width, me.minWidth, me.maxWidth);
+
+            
+            if (adjustX) {
+                newBox.x = box.x + (box.width - newBox.width);
+            }
+        } else {
+            me.lastX = newBox.x;
+        }
+        if (newBox.height < me.minHeight || newBox.height > me.maxHeight) {
+            newBox.height = Ext.Number.constrain(newBox.height, me.minHeight, me.maxHeight);
+
+            
+            if (adjustY) {
+                newBox.y = box.y + (box.height - newBox.height);
+            }
+        } else {
+            me.lastY = newBox.y;
+        }
+
+        
+        if (me.preserveRatio || e.shiftKey) {
+            ratio = me.startBox.width / me.startBox.height;
+
+            
+            newHeight = Math.min(Math.max(me.minHeight, newBox.width / ratio), me.maxHeight);
+            newWidth = Math.min(Math.max(me.minWidth, newBox.height * ratio), me.maxWidth);
+
+            
+            if (axis == 1) {
+                newBox.height = newHeight;
+            }
+
+            
+            else if (axis == 2) {
+                newBox.width = newWidth;
+            }
+
+            
+            else {
+                
+                
+                dragRatio = Math.abs(oppositeCorner[0] - this.lastXY[0]) / Math.abs(oppositeCorner[1] - this.lastXY[1]);
+
+                
+                if (dragRatio > ratio) {
+                    newBox.height = newHeight;
+                } else {
+                    newBox.width = newWidth;
+                }
+
+                
+                if (region == 'northeast') {
+                    newBox.y = box.y - (newBox.height - box.height);
+                } else if (region == 'northwest') {
+                    newBox.y = box.y - (newBox.height - box.height);
+                    newBox.x = box.x - (newBox.width - box.width);
+                } else if (region == 'southwest') {
+                    newBox.x = box.x - (newBox.width - box.width);
+                }
+            }
+        }
+
+        if (heightAdjust === 0) {
+            vertDir = 'none';
+        }
+        if (widthAdjust === 0) {
+            horizDir = 'none';
+        }
+        me.resize(newBox, {
+            horizontal: horizDir,
+            vertical: vertDir
+        }, atEnd);
+    },
+
+    getResizeTarget: function(atEnd) {
+        return atEnd ? this.target : this.getDynamicTarget();
+    },
+
+    resize: function(box, direction, atEnd) {
+        var target = this.getResizeTarget(atEnd);
+        if (target.isComponent) {
+            target.setSize(box.width, box.height);
+            if (target.floating) {
+                target.setPagePosition(box.x, box.y);
+            }
+        } else {
+            target.setBox(box);
+        }
+
+        
+        target = this.originalTarget;
+        if (target && (this.dynamic || atEnd)) {
+            if (target.isComponent) {
+                target.setSize(box.width, box.height);
+                if (target.floating) {
+                    target.setPagePosition(box.x, box.y);
+                }
+            } else {
+                target.setBox(box);
+            }
+        }
+    },
+
+    onEnd: function(e) {
+        this.updateDimensions(e, true);
+        if (this.proxy) {
+            this.proxy.hide();
+        }
+    }
+});
+
+
+Ext.define('Ext.resizer.Resizer', {
+    mixins: {
+        observable: 'Ext.util.Observable'
+    },
+    uses: ['Ext.resizer.ResizeTracker', 'Ext.Component'],
+
+    alternateClassName: 'Ext.Resizable',
+
+    handleCls: Ext.baseCSSPrefix + 'resizable-handle',
+    pinnedCls: Ext.baseCSSPrefix + 'resizable-pinned',
+    overCls:   Ext.baseCSSPrefix + 'resizable-over',
+    wrapCls:   Ext.baseCSSPrefix + 'resizable-wrap',
+
+    
+    dynamic: true,
+
+    
+    handles: 's e se',
+
+    
+    height : null,
+
+    
+    width : null,
+
+    
+    heightIncrement : 0,
+
+    
+    widthIncrement : 0,
+
+    
+    minHeight : 20,
+
+    
+    minWidth : 20,
+
+    
+    maxHeight : 10000,
+
+    
+    maxWidth : 10000,
+
+    
+    pinned: false,
+
+    
+    preserveRatio: false,
+
+    
+    transparent: false,
+
+    
+
+    possiblePositions: {
+        n:  'north',
+        s:  'south',
+        e:  'east',
+        w:  'west',
+        se: 'southeast',
+        sw: 'southwest',
+        nw: 'northwest',
+        ne: 'northeast'
+    },
+
+    
+
+    
+
+    constructor: function(config) {
+        var me = this,
+            target,
+            targetEl,
+            tag,
+            handles = me.handles,
+            handleCls,
+            possibles,
+            len,
+            i = 0,
+            pos, 
+            handleEls = [],
+            eastWestStyle, style,
+            box;
+
+        me.addEvents(
+            
+            'beforeresize',
+            
+            'resizedrag',
+            
+            'resize'
+        );
+
+        if (Ext.isString(config) || Ext.isElement(config) || config.dom) {
+            target = config;
+            config = arguments[1] || {};
+            config.target = target;
+        }
+        
+        me.mixins.observable.constructor.call(me, config);
+
+        
+        
+        target = me.target;
+        if (target) {
+            if (target.isComponent) {
+                me.el = target.getEl();
+                if (target.minWidth) {
+                    me.minWidth = target.minWidth;
+                }
+                if (target.minHeight) {
+                    me.minHeight = target.minHeight;
+                }
+                if (target.maxWidth) {
+                    me.maxWidth = target.maxWidth;
+                }
+                if (target.maxHeight) {
+                    me.maxHeight = target.maxHeight;
+                }
+                if (target.floating) {
+                    if (!me.hasOwnProperty('handles')) {
+                        me.handles = 'n ne e se s sw w nw';
+                    }
+                }
+            } else {
+                me.el = me.target = Ext.get(target);
+            }
+        }
+        
+        else {
+            me.target = me.el = Ext.get(me.el);
+        }
+
+        
+        
+        
+        tag = me.el.dom.tagName.toUpperCase();
+        if (tag == 'TEXTAREA' || tag == 'IMG' || tag == 'TABLE') {
+            
+            me.originalTarget = me.target;
+            targetEl = me.el;
+            box = targetEl.getBox();
+            me.target = me.el = me.el.wrap({
+                cls: me.wrapCls,
+                id: me.el.id + '-rzwrap',
+                style: targetEl.getStyles('margin-top', 'margin-bottom')
+            });
+
+            
+            me.el.setPositioning(targetEl.getPositioning());
+            targetEl.clearPositioning();
+            me.el.setBox(box);
+
+            
+            targetEl.setStyle('position', 'absolute');
+        }
+
+        
+        
+        me.el.position();
+        if (me.pinned) {
+            me.el.addCls(me.pinnedCls);
+        }
+
+        
+        me.resizeTracker = new Ext.resizer.ResizeTracker({
+            disabled: me.disabled,
+            target: me.target,
+            constrainTo: me.constrainTo,
+            overCls: me.overCls,
+            throttle: me.throttle,
+            originalTarget: me.originalTarget,
+            delegate: '.' + me.handleCls,
+            dynamic: me.dynamic,
+            preserveRatio: me.preserveRatio,
+            heightIncrement: me.heightIncrement,
+            widthIncrement: me.widthIncrement,
+            minHeight: me.minHeight,
+            maxHeight: me.maxHeight,
+            minWidth: me.minWidth,
+            maxWidth: me.maxWidth
+        });
+
+        
+        me.resizeTracker.on({
+            mousedown: me.onBeforeResize,
+            drag: me.onResize,
+            dragend: me.onResizeEnd,
+            scope: me
+        });
+
+        if (me.handles == 'all') {
+            me.handles = 'n s e w ne nw se sw';
+        }
+
+        handles = me.handles = me.handles.split(/ |\s*?[,;]\s*?/);
+        possibles = me.possiblePositions;
+        len = handles.length;
+        handleCls = me.handleCls + ' ' + (me.target.isComponent ? (me.target.baseCls + '-handle ') : '') + me.handleCls + '-';
+
+        
+        eastWestStyle = Ext.isIE6 ? ' style="height:' + me.el.getHeight() + 'px"' : '';
+
+        for (; i < len; i++){
+            
+            if (handles[i] && possibles[handles[i]]) {
+                pos = possibles[handles[i]];
+                if (pos === 'east' || pos === 'west') {
+                    style = eastWestStyle;
+                } else {
+                    style = '';
+                }
+                handleEls.push('<div id="' + me.el.id + '-' + pos + '-handle" class="' + handleCls + pos + ' ' + Ext.baseCSSPrefix + 'unselectable"' + style + '></div>');
+            }
+        }
+        Ext.DomHelper.append(me.el, handleEls.join(''));
+
+        
+        for (i = 0; i < len; i++){
+            
+            if (handles[i] && possibles[handles[i]]) {
+                pos = possibles[handles[i]];
+                me[pos] = me.el.getById(me.el.id + '-' + pos + '-handle');
+                me[pos].region = pos;
+                me[pos].unselectable();
+                if (me.transparent) {
+                    me[pos].setOpacity(0);
+                }
+            }
+        }
+
+        
+        if (Ext.isNumber(me.width)) {
+            me.width = Ext.Number.constrain(me.width, me.minWidth, me.maxWidth);
+        }
+        if (Ext.isNumber(me.height)) {
+            me.height = Ext.Number.constrain(me.height, me.minHeight, me.maxHeight);
+        }
+
+        
+        if (me.width !== null || me.height !== null) {
+            if (me.originalTarget) {
+                me.originalTarget.setWidth(me.width);
+                me.originalTarget.setHeight(me.height);
+            }
+            me.resizeTo(me.width, me.height);
+        }
+
+        me.forceHandlesHeight();
+    },
+
+    disable: function() {
+        this.resizeTracker.disable();
+    },
+
+    enable: function() {
+        this.resizeTracker.enable();
+    },
+
+    
+    onBeforeResize: function(tracker, e) {
+        var box = this.el.getBox();
+        return this.fireEvent('beforeresize', this, box.width, box.height, e);
+    },
+
+    
+    onResize: function(tracker, e) {
+        var me = this,
+            box = me.el.getBox();
+            
+        me.forceHandlesHeight();
+        return me.fireEvent('resizedrag', me, box.width, box.height, e);
+    },
+
+    
+    onResizeEnd: function(tracker, e) {
+        var me = this,
+            box = me.el.getBox();
+            
+        me.forceHandlesHeight();
+        return me.fireEvent('resize', me, box.width, box.height, e);
+    },
+
+    
+    resizeTo : function(width, height) {
+        var me = this;
+        me.target.setSize(width, height);
+        me.fireEvent('resize', me, width, height, null);
+    },
+
+    
+    getEl : function() {
+        return this.el;
+    },
+
+    
+    getTarget: function() {
+        return this.target;
+    },
+
+    destroy: function() {
+        var i = 0,
+            handles = this.handles,
+            len = handles.length,
+            positions = this.possiblePositions;
+
+        for (; i < len; i++) {
+            this[positions[handles[i]]].remove();
+        }
+    },
+
+    
+    forceHandlesHeight : function() {
+        var me = this,
+            handle;
+        if (Ext.isIE6) {
+            handle = me.east;
+            if (handle) {
+                handle.setHeight(me.el.getHeight());
+            }
+            handle = me.west;
+            if (handle) {
+                handle.setHeight(me.el.getHeight());
+            }
+            me.el.repaint();
+        }
+    }
+});
+
+
+Ext.define('Ext.selection.CellModel', {
+    extend: 'Ext.selection.Model',
+    alias: 'selection.cellmodel',
+    requires: ['Ext.util.KeyNav'],
+
+    isCellModel: true,
+
+    
+    enableKeyNav: true,
+
+    
+    preventWrap: false,
+
+    
+    noSelection: {
+        row: -1,
+        column: -1
+    },
+
+    constructor: function() {
+        this.addEvents(
+            
+            'deselect',
+
+            
+            'select'
+        );
+        this.callParent(arguments);
+    },
+
+    bindComponent: function(view) {
+        var me = this,
+            grid = view.ownerCt;
+        me.primaryView = view;
+        me.views = me.views || [];
+        me.views.push(view);
+        me.bindStore(view.getStore(), true);
+
+        view.on({
+            cellmousedown: me.onMouseDown,
+            refresh: me.onViewRefresh,
+            scope: me
+        });
+        if (grid.optimizedColumnMove !== false) {
+            grid.on('columnmove', me.onColumnMove, me);
+        }
+
+        if (me.enableKeyNav) {
+            me.initKeyNav(view);
+        }
+    },
+
+    initKeyNav: function(view) {
+        var me = this;
+
+        if (!view.rendered) {
+            view.on('render', Ext.Function.bind(me.initKeyNav, me, [view], 0), me, {single: true});
+            return;
+        }
+
+        view.el.set({
+            tabIndex: -1
+        });
+
+        
+        
+        me.keyNav = new Ext.util.KeyNav({
+            target: view.el,
+            ignoreInputFields: true,
+            up: me.onKeyUp,
+            down: me.onKeyDown,
+            right: me.onKeyRight,
+            left: me.onKeyLeft,
+            tab: me.onKeyTab,
+            scope: me
+        });
+    },
+
+    getHeaderCt: function() {
+        var selection = this.getCurrentPosition(),
+            view = selection ? selection.view : this.primaryView;
+
+        return view.headerCt;
+    },
+
+    onKeyUp: function(e, t) {
+        this.keyNavigation = true;
+        this.move('up', e);
+        this.keyNavigation = false;
+    },
+
+    onKeyDown: function(e, t) {
+        this.keyNavigation = true;
+        this.move('down', e);
+        this.keyNavigation = false;
+    },
+
+    onKeyLeft: function(e, t) {
+        this.keyNavigation = true;
+        this.move('left', e);
+        this.keyNavigation = false;
+    },
+
+    onKeyRight: function(e, t) {
+        this.keyNavigation = true;
+        this.move('right', e);
+        this.keyNavigation = false;
+    },
+
+    move: function(dir, e) {
+        var me = this,
+            pos = me.getCurrentPosition(),
+            
+            
+            newPos = pos.view.walkCells(pos, dir, e, me.preventWrap);
+
+        
+        if (newPos) {
+            newPos.view = pos.view;
+            return me.setCurrentPosition(newPos);
+        }
+    },
+
+    
+    getCurrentPosition: function() {
+        return this.selection;
+    },
+
+    
+    setCurrentPosition: function(pos) {
+        var me = this;
+
+        
+        me.lastSelection = me.selection;
+        if (me.selection) {
+            me.onCellDeselect(me.selection);
+        }
+
+        if (pos) {
+            me.nextSelection = new me.Selection(me);
+            me.nextSelection.setPosition(pos);
+            me.onCellSelect(me.nextSelection);
+
+            
+            return me.selection = me.nextSelection;
+        }
+    },
+
+    
+    onStoreRemove: function(store, record, index) {
+        var me = this,
+            pos = me.getCurrentPosition();
+
+        me.callParent(arguments);
+        if (pos) {
+            
+            
+            if (pos.row == index) {
+                if (index < store.getCount() - 1) {
+                    pos.setPosition(index, pos.column);
+                    me.setCurrentPosition(pos);
+                } else {
+                    delete me.selection;
+                }
+            }
+            
+            
+            else if (index < pos.row) {
+                pos.setPosition(pos.row - 1, pos.column);
+                me.setCurrentPosition(pos);
+            }
+        }
+    },
+
+    
+    onMouseDown: function(view, cell, cellIndex, record, row, rowIndex, e) {
+        this.setCurrentPosition({
+            view: view,
+            row: rowIndex,
+            column: cellIndex
+        });
+    },
+
+    
+    
+    onCellSelect: function(position, supressEvent) {
+        if (position && position.row !== undefined && position.row > -1) {
+            this.doSelect(position.view.getStore().getAt(position.row), false, supressEvent);
+        }
+    },
+
+    
+    
+    onCellDeselect: function(position, supressEvent) {
+        if (position && position.row !== undefined) {
+            this.doDeselect(position.view.getStore().getAt(position.row), supressEvent);
+        }
+    },
+
+    onSelectChange: function(record, isSelected, suppressEvent, commitFn) {
+        var me = this,
+            pos,
+            eventName,
+            view;
+
+        if (isSelected) {
+            pos = me.nextSelection;
+            eventName = 'select';
+        } else {
+            pos = me.lastSelection || me.noSelection;
+            eventName = 'deselect';
+        }
+
+        
+        
+        
+        view = pos.view || me.primaryView;
+
+        if ((suppressEvent || me.fireEvent('before' + eventName, me, record, pos.row, pos.column)) !== false &&
+                commitFn() !== false) {
+
+            if (isSelected) {
+                view.onCellSelect(pos);
+                view.onCellFocus(pos);
+            } else {
+                view.onCellDeselect(pos);
+                delete me.selection;
+            }
+
+            if (!suppressEvent) {
+                me.fireEvent(eventName, me, record, pos.row, pos.column);
+            }
+        }
+    },
+
+    
+    onKeyTab: function(e, t) {
+        var me = this,
+            editingPlugin = me.getCurrentPosition().view.editingPlugin;
+
+        
+        if (editingPlugin && me.wasEditing) {
+            me.onEditorTab(editingPlugin, e)
+        } else {
+            me.move(e.shiftKey ? 'left' : 'right', e);
+        }
+    },
+
+    onEditorTab: function(editingPlugin, e) {
+        var me = this,
+            direction = e.shiftKey ? 'left' : 'right',
+            position  = me.move(direction, e);
+
+        
+        if (position) {
+            
+            if (editingPlugin.startEditByPosition(position)) {
+                me.wasEditing = false;
+            }
+            
+            
+            else {
+                me.wasEditing = true;
+                if (!position.columnHeader.dataIndex) {
+                    me.onEditorTab(editingPlugin, e);
+                }
+            }
+        }
+    },
+
+    refresh: function() {
+        var pos = this.getCurrentPosition(),
+            selRowIdx;
+
+        
+        if (pos && (selRowIdx = this.store.indexOf(this.selected.last())) !== -1) {
+            pos.row = selRowIdx;
+        }
+    },
+
+    
+    onColumnMove: function(headerCt, header, fromIdx, toIdx) {
+        var grid = headerCt.up('tablepanel');
+        if (grid) {
+            this.onViewRefresh(grid.view);
+        }
+    },
+
+    onViewRefresh: function(view) {
+        var me = this,
+            pos = me.getCurrentPosition(),
+            headerCt = view.headerCt,
+            record, columnHeader;
+
+        
+        
+        if (pos && pos.view === view) {
+            record = pos.record;
+            columnHeader = pos.columnHeader;
+
+            
+            if (!columnHeader.isDescendantOf(headerCt)) {
+                
+                
+                
+                columnHeader = headerCt.queryById(columnHeader.id) || 
+                               headerCt.down('[text="' + columnHeader.text + '"]') ||
+                               headerCt.down('[dataIndex="' + columnHeader.dataIndex + '"]');
+            }
+
+            
+            
+            
+            
+            if (columnHeader && (view.store.indexOfId(record.getId()) !== -1)) {
+                me.setCurrentPosition({
+                    row: record,
+                    column: columnHeader,
+                    view: view
+                });
+            }
+        }
+    },
+
+    selectByPosition: function(position) {
+        this.setCurrentPosition(position);
+    }
+}, function() {
+    
+    
+    
+    var Selection = this.prototype.Selection = function(model) {
+        this.model = model;
+    };
+    
+    Selection.prototype.setPosition = function(row, col) {
+        var me = this,
+            view;
+
+        
+        if (arguments.length === 1) {
+            
+            
+            
+            if (row.view) {
+                me.view = view = row.view;
+            }
+            col = row.column;
+            row = row.row;
+        }
+        
+        
+        
+        if (!view) {
+            me.view = view = me.model.primaryView;
+        }
+
+        
+        if (typeof row === 'number') {
+            me.row = row;
+            me.record = view.store.getAt(row);
+        }
+        
+        else if (row.isModel) {
+            me.record = row;
+            me.row = view.indexOf(row);
+        }
+        
+        else if (row.tagName) {
+            me.record = view.getRecord(row);
+            me.row = view.indexOf(me.record);
+        }
+        
+        
+        if (typeof col === 'number') {
+            me.column = col;
+            me.columnHeader = view.getHeaderAtIndex(col);
+        }
+        
+        else {
+            me.columnHeader = col;
+            me.column = col.getIndex();
+        }
+        return me;
+    }
+});
+
+
+Ext.define('Ext.selection.RowModel', {
+    extend: 'Ext.selection.Model',
+    alias: 'selection.rowmodel',
+    requires: ['Ext.util.KeyNav'],
+
+    
+    deltaScroll: 5,
+
+    
+    enableKeyNav: true,
+    
+    
+    ignoreRightMouseSelection: false,
+
+    constructor: function() {
+        this.addEvents(
+            
+            'beforedeselect',
+
+            
+            'beforeselect',
+
+            
+            'deselect',
+
+            
+            'select'
+        );
+        this.views = [];
+        this.callParent(arguments);
+    },
+
+    bindComponent: function(view) {
+        var me = this;
+
+        me.views = me.views || [];
+        me.views.push(view);
+        me.bindStore(view.getStore(), true);
+
+        view.on({
+            itemmousedown: me.onRowMouseDown,
+            scope: me
+        });
+
+        if (me.enableKeyNav) {
+            me.initKeyNav(view);
+        }
+    },
+
+    initKeyNav: function(view) {
+        var me = this;
+
+        if (!view.rendered) {
+            view.on('render', Ext.Function.bind(me.initKeyNav, me, [view], 0), me, {single: true});
+            return;
+        }
+
+        
+        
+        view.el.set({
+            tabIndex: -1
+        });
+
+        
+        me.keyNav = new Ext.util.KeyNav({
+            target: view,
+            ignoreInputFields: true,
+            eventName: 'itemkeydown',
+            processEvent: function(view, record, node, index, event) {
+                event.record = record;
+                event.recordIndex = index;
+                return event;
+            },
+            up: me.onKeyUp,
+            down: me.onKeyDown,
+            right: me.onKeyRight,
+            left: me.onKeyLeft,
+            pageDown: me.onKeyPageDown,
+            pageUp: me.onKeyPageUp,
+            home: me.onKeyHome,
+            end: me.onKeyEnd,
+            space: me.onKeySpace,
+            enter: me.onKeyEnter,
+            scope: me
+        });
+    },
+
+    
+    
+    
+    getRowsVisible: function() {
+        var rowsVisible = false,
+            view = this.views[0],
+            row = view.getNode(0),
+            rowHeight, gridViewHeight;
+
+        if (row) {
+            rowHeight = Ext.fly(row).getHeight();
+            gridViewHeight = view.el.getHeight();
+            rowsVisible = Math.floor(gridViewHeight / rowHeight);
+        }
+
+        return rowsVisible;
+    },
+
+    
+    onKeyEnd: function(e) {
+        var me = this,
+            last = me.store.getAt(me.store.getCount() - 1);
+
+        if (last) {
+            if (e.shiftKey) {
+                me.selectRange(last, me.lastFocused || 0);
+                me.setLastFocused(last);
+            } else if (e.ctrlKey) {
+                me.setLastFocused(last);
+            } else {
+                me.doSelect(last);
+            }
+        }
+    },
+
+    
+    onKeyHome: function(e) {
+        var me = this,
+            first = me.store.getAt(0);
+
+        if (first) {
+            if (e.shiftKey) {
+                me.selectRange(first, me.lastFocused || 0);
+                me.setLastFocused(first);
+            } else if (e.ctrlKey) {
+                me.setLastFocused(first);
+            } else {
+                me.doSelect(first, false);
+            }
+        }
+    },
+
+    
+    onKeyPageUp: function(e) {
+        var me = this,
+            rowsVisible = me.getRowsVisible(),
+            selIdx,
+            prevIdx,
+            prevRecord;
+
+        if (rowsVisible) {
+            selIdx = e.recordIndex;
+            prevIdx = selIdx - rowsVisible;
+            if (prevIdx < 0) {
+                prevIdx = 0;
+            }
+            prevRecord = me.store.getAt(prevIdx);
+            if (e.shiftKey) {
+                me.selectRange(prevRecord, e.record, e.ctrlKey, 'up');
+                me.setLastFocused(prevRecord);
+            } else if (e.ctrlKey) {
+                e.preventDefault();
+                me.setLastFocused(prevRecord);
+            } else {
+                me.doSelect(prevRecord);
+            }
+
+        }
+    },
+
+    
+    onKeyPageDown: function(e) {
+        var me = this,
+            rowsVisible = me.getRowsVisible(),
+            selIdx,
+            nextIdx,
+            nextRecord;
+
+        if (rowsVisible) {
+            selIdx = e.recordIndex;
+            nextIdx = selIdx + rowsVisible;
+            if (nextIdx >= me.store.getCount()) {
+                nextIdx = me.store.getCount() - 1;
+            }
+            nextRecord = me.store.getAt(nextIdx);
+            if (e.shiftKey) {
+                me.selectRange(nextRecord, e.record, e.ctrlKey, 'down');
+                me.setLastFocused(nextRecord);
+            } else if (e.ctrlKey) {
+                
+                
+                e.preventDefault();
+                me.setLastFocused(nextRecord);
+            } else {
+                me.doSelect(nextRecord);
+            }
+        }
+    },
+
+    
+    
+    onKeySpace: function(e) {
+        var me = this,
+            record = me.lastFocused;
+
+        if (record) {
+            if (me.isSelected(record)) {
+                me.doDeselect(record, false);
+            } else {
+                me.doSelect(record, true);
+            }
+        }
+    },
+    
+    onKeyEnter: Ext.emptyFn,
+
+    
+    
+    
+    onKeyUp: function(e) {
+        var me = this,
+            idx  = me.store.indexOf(me.lastFocused),
+            record;
+
+        if (idx > 0) {
+            
+            
+            record = me.store.getAt(idx - 1);
+            if (e.shiftKey && me.lastFocused) {
+                if (me.isSelected(me.lastFocused) && me.isSelected(record)) {
+                    me.doDeselect(me.lastFocused, true);
+                    me.setLastFocused(record);
+                } else if (!me.isSelected(me.lastFocused)) {
+                    me.doSelect(me.lastFocused, true);
+                    me.doSelect(record, true);
+                } else {
+                    me.doSelect(record, true);
+                }
+            } else if (e.ctrlKey) {
+                me.setLastFocused(record);
+            } else {
+                me.doSelect(record);
+                
+            }
+        }
+        
+        
+        
+        
+        
+        
+        
+    },
+
+    
+    
+    
+    onKeyDown: function(e) {
+        var me = this,
+            idx  = me.store.indexOf(me.lastFocused),
+            record;
+
+        
+        
+        if (idx + 1 < me.store.getCount()) {
+            record = me.store.getAt(idx + 1);
+            if (me.selected.getCount() === 0) {
+                if (!e.ctrlKey) {
+                    me.doSelect(record);
+                } else {
+                    me.setLastFocused(record);
+                }
+                
+            } else if (e.shiftKey && me.lastFocused) {
+                if (me.isSelected(me.lastFocused) && me.isSelected(record)) {
+                    me.doDeselect(me.lastFocused, true);
+                    me.setLastFocused(record);
+                } else if (!me.isSelected(me.lastFocused)) {
+                    me.doSelect(me.lastFocused, true);
+                    me.doSelect(record, true);
+                } else {
+                    me.doSelect(record, true);
+                }
+            } else if (e.ctrlKey) {
+                me.setLastFocused(record);
+            } else {
+                me.doSelect(record);
+                
+            }
+        }
+    },
+
+    scrollByDeltaX: function(delta) {
+        var view    = this.views[0],
+            section = view.up(),
+            hScroll = section.horizontalScroller;
+
+        if (hScroll) {
+            hScroll.scrollByDeltaX(delta);
+        }
+    },
+
+    onKeyLeft: function(e) {
+        this.scrollByDeltaX(-this.deltaScroll);
+    },
+
+    onKeyRight: function(e) {
+        this.scrollByDeltaX(this.deltaScroll);
+    },
+
+    
+    
+    onRowMouseDown: function(view, record, item, index, e) {
+        if (!this.allowRightMouseSelection(e)) {
+            return;
+        }
+
+        if (e.button === 0 || !this.isSelected(record)) {
+            this.selectWithEvent(record, e);
+        }
+    },
+    
+    
+    allowRightMouseSelection: function(e) {
+        var disallow = this.ignoreRightMouseSelection && e.button !== 0;
+        if (disallow) {
+            disallow = this.hasSelection();
+        }
+        return !disallow;
+    },
+
+    
+    
+    onSelectChange: function(record, isSelected, suppressEvent, commitFn) {
+        var me      = this,
+            views   = me.views,
+            viewsLn = views.length,
+            store   = me.store,
+            rowIdx  = store.indexOf(record),
+            eventName = isSelected ? 'select' : 'deselect',
+            i = 0;
+
+        if ((suppressEvent || me.fireEvent('before' + eventName, me, record, rowIdx)) !== false &&
+                commitFn() !== false) {
+
+            for (; i < viewsLn; i++) {
+                if (isSelected) {
+                    views[i].onRowSelect(rowIdx, suppressEvent);
+                } else {
+                    views[i].onRowDeselect(rowIdx, suppressEvent);
+                }
+            }
+
+            if (!suppressEvent) {
+                me.fireEvent(eventName, me, record, rowIdx);
+            }
+        }
+    },
+
+    
+    
+    onLastFocusChanged: function(oldFocused, newFocused, supressFocus) {
+        var views   = this.views,
+            viewsLn = views.length,
+            store   = this.store,
+            rowIdx,
+            i = 0;
+
+        if (oldFocused) {
+            rowIdx = store.indexOf(oldFocused);
+            if (rowIdx != -1) {
+                for (; i < viewsLn; i++) {
+                    views[i].onRowFocus(rowIdx, false);
+                }
+            }
+        }
+
+        if (newFocused) {
+            rowIdx = store.indexOf(newFocused);
+            if (rowIdx != -1) {
+                for (i = 0; i < viewsLn; i++) {
+                    views[i].onRowFocus(rowIdx, true, supressFocus);
+                }
+            }
+        }
+        this.callParent();
+    },
+
+    onEditorTab: function(editingPlugin, e) {
+        var me = this,
+            view = me.views[0],
+            record = editingPlugin.getActiveRecord(),
+            header = editingPlugin.getActiveColumn(),
+            position = view.getPosition(record, header),
+            direction = e.shiftKey ? 'left' : 'right';
+
+        do {
+            position  = view.walkCells(position, direction, e, me.preventWrap);
+        } while(position && !view.headerCt.getHeaderAtIndex(position.column).getEditor());
+
+        if (position) {
+            editingPlugin.startEditByPosition(position);
+        }
+    },
+
+
+    
+    getCurrentPosition: function() {
+        var firstSelection = this.selected.items[0];
+        if (firstSelection) {
+            return {
+                row: this.store.indexOf(firstSelection),
+                column: 0
+            };
+        }
+    },
+
+    selectByPosition: function(position) {
+        var record = this.store.getAt(position.row);
+        this.select(record);
+    },
+
+
+    
+    selectNext: function(keepExisting, suppressEvent) {
+        var me = this,
+            store = me.store,
+            selection = me.getSelection(),
+            record = selection[selection.length - 1],
+            index = store.indexOf(record) + 1,
+            success;
+
+        if(index === store.getCount() || index === 0) {
+            success = false;
+        } else {
+            me.doSelect(index, keepExisting, suppressEvent);
+            success = true;
+        }
+        return success;
+    },
+
+    
+    selectPrevious: function(keepExisting, suppressEvent) {
+        var me = this,
+            selection = me.getSelection(),
+            record = selection[0],
+            index = me.store.indexOf(record) - 1,
+            success;
+
+        if (index < 0) {
+            success = false;
+        } else {
+            me.doSelect(index, keepExisting, suppressEvent);
+            success = true;
+        }
+        return success;
+    }
+});
+
+
+Ext.define('Ext.selection.CheckboxModel', {
+    alias: 'selection.checkboxmodel',
+    extend: 'Ext.selection.RowModel',
+
+    
+    mode: 'MULTI',
+
+    
+    injectCheckbox: 0,
+
+    
+    checkOnly: false,
+    
+    
+    showHeaderCheckbox: true,
+
+    headerWidth: 24,
+
+    
+    checkerOnCls: Ext.baseCSSPrefix + 'grid-hd-checker-on',
+
+    
+    refreshOnRemove: true,
+
+    beforeViewRender: function(view) {
+        var me = this;
+        me.callParent(arguments);
+
+        
+        if (!me.hasLockedHeader() || view.headerCt.lockedCt) {
+            if (me.showHeaderCheckbox !== false) {
+                view.headerCt.on('headerclick', me.onHeaderClick, me);
+            }
+            me.addCheckbox(view, true);
+            me.mon(view.ownerCt, 'reconfigure', me.onReconfigure, me);
+        }
+    },
+
+    bindComponent: function(view) {
+        var me = this;
+        me.sortable = false;
+        me.callParent(arguments);
+    },
+
+    hasLockedHeader: function(){
+        var views     = this.views,
+            vLen      = views.length,
+            v;
+
+        for (v = 0; v < vLen; v++) {
+            if (views[v].headerCt.lockedCt) {
+                return true;
+            }
+        }
+        return false;
+    },
+
+    
+    addCheckbox: function(view, initial){
+        var me = this,
+            checkbox = me.injectCheckbox,
+            headerCt = view.headerCt;
+
+        
+        if (checkbox !== false) {
+            if (checkbox == 'first') {
+                checkbox = 0;
+            } else if (checkbox == 'last') {
+                checkbox = headerCt.getColumnCount();
+            }
+            Ext.suspendLayouts();
+            headerCt.add(checkbox,  me.getHeaderConfig());
+            Ext.resumeLayouts();
+        }
+
+        if (initial !== true) {
+            view.refresh();
+        }
+    },
+
+    
+    onReconfigure: function(grid, store, columns) {
+        if(columns) {
+            this.addCheckbox(this.views[0]);
+        }
+    },
+
+    
+    toggleUiHeader: function(isChecked) {
+        var view     = this.views[0],
+            headerCt = view.headerCt,
+            checkHd  = headerCt.child('gridcolumn[isCheckerHd]');
+
+        if (checkHd) {
+            if (isChecked) {
+                checkHd.el.addCls(this.checkerOnCls);
+            } else {
+                checkHd.el.removeCls(this.checkerOnCls);
+            }
+        }
+    },
+
+    
+    onHeaderClick: function(headerCt, header, e) {
+        if (header.isCheckerHd) {
+            e.stopEvent();
+            var me = this,
+                isChecked = header.el.hasCls(Ext.baseCSSPrefix + 'grid-hd-checker-on');
+                
+            
+            me.preventFocus = true;
+            if (isChecked) {
+                me.deselectAll();
+            } else {
+                me.selectAll();
+            }
+            delete me.preventFocus;
+        }
+    },
+
+    
+    getHeaderConfig: function() {
+        var me = this,
+            showCheck = me.showHeaderCheckbox !== false;
+
+        return {
+            isCheckerHd: showCheck,
+            text : '&#160;',
+            width: me.headerWidth,
+            sortable: false,
+            draggable: false,
+            resizable: false,
+            hideable: false,
+            menuDisabled: true,
+            dataIndex: '',
+            cls: showCheck ? Ext.baseCSSPrefix + 'column-header-checkbox ' : '',
+            renderer: Ext.Function.bind(me.renderer, me),
+            editRenderer: me.editRenderer || me.renderEmpty,
+            locked: me.hasLockedHeader()
+        };
+    },
+    
+    renderEmpty: function(){
+        return '&#160;';    
+    },
+
+    
+    renderer: function(value, metaData, record, rowIndex, colIndex, store, view) {
+        var baseCSSPrefix = Ext.baseCSSPrefix;
+        metaData.tdCls = baseCSSPrefix + 'grid-cell-special ' + baseCSSPrefix + 'grid-cell-row-checker';
+        return '<div class="' + baseCSSPrefix + 'grid-row-checker">&#160;</div>';
+    },
+
+    
+    onRowMouseDown: function(view, record, item, index, e) {
+        view.el.focus();
+        var me = this,
+            checker = e.getTarget('.' + Ext.baseCSSPrefix + 'grid-row-checker'),
+            mode;
+            
+        if (!me.allowRightMouseSelection(e)) {
+            return;
+        }
+
+        
+        if (me.checkOnly && !checker) {
+            return;
+        }
+
+        if (checker) {
+            mode = me.getSelectionMode();
+            
+            
+            if (mode !== 'SINGLE') {
+                me.setSelectionMode('SIMPLE');
+            }
+            me.selectWithEvent(record, e);
+            me.setSelectionMode(mode);
+        } else {
+            me.selectWithEvent(record, e);
+        }
+    },
+
+    
+    onSelectChange: function() {
+        var me = this;
+        me.callParent(arguments);
+        me.updateHeaderState();
+    },
+
+    
+    onStoreLoad: function() {
+        var me = this;
+        me.callParent(arguments);
+        me.updateHeaderState();
+    },
+
+    
+    updateHeaderState: function() {
+        
+        var hdSelectStatus = this.selected.getCount() === this.store.getCount();
+        this.toggleUiHeader(hdSelectStatus);
+    }
+});
+
+
+Ext.define('Ext.selection.TreeModel', {
+    extend: 'Ext.selection.RowModel',
+    alias: 'selection.treemodel',
+    
+    
+    
+    
+    pruneRemoved: false,
+    
+    onKeyRight: function(e, t) {
+        var focused = this.getLastFocused(),
+            view    = this.view;
+            
+        if (focused) {
+            
+            
+            
+            if (focused.isExpanded()) {
+                this.onKeyDown(e, t);
+            
+            } else if (focused.isExpandable()) {
+                view.expand(focused);
+            }
+        }
+    },
+    
+    onKeyLeft: function(e, t) {
+        var focused = this.getLastFocused(),
+            view    = this.view,
+            viewSm  = view.getSelectionModel(),
+            parentNode, parentRecord;
+
+        if (focused) {
+            parentNode = focused.parentNode;
+            
+            if (focused.isExpanded()) {
+                view.collapse(focused);
+            
+            
+            } else if (parentNode && !parentNode.isRoot()) {
+                
+                if (e.shiftKey) {
+                    viewSm.selectRange(parentNode, focused, e.ctrlKey, 'up');
+                    viewSm.setLastFocused(parentNode);
+                
+                } else if (e.ctrlKey) {
+                    viewSm.setLastFocused(parentNode);
+                
+                } else {
+                    viewSm.select(parentNode);
+                }
+            }
+        }
+    },
+    
+    onKeySpace: function(e, t) {
+        this.toggleCheck(e);
+    },
+    
+    onKeyEnter: function(e, t) {
+        this.toggleCheck(e);
+    },
+    
+    toggleCheck: function(e){
+        e.stopEvent();
+        var selected = this.getLastSelected();
+        if (selected) {
+            this.view.onCheckChange(selected);
+        }
+    }
+});
+
+
+Ext.define('Ext.slider.Thumb', {
+    requires: ['Ext.dd.DragTracker', 'Ext.util.Format'],
+    
+    topZIndex: 10000,
+
+    
+
+    
+    constructor: function(config) {
+        var me = this;
+
+        
+        Ext.apply(me, config || {}, {
+            cls: Ext.baseCSSPrefix + 'slider-thumb',
+
+            
+            constrain: false
+        });
+        me.callParent([config]);
+    },
+
+    
+    render: function() {
+        var me = this;
+        me.el = me.slider.innerEl.insertFirst(me.getElConfig());
+        me.onRender();
+    },
+    
+    onRender: function() {
+        if (this.disabled) {
+            this.disable();
+        }
+        this.initEvents();
+    },
+
+    getElConfig: function() {
+        var me = this,
+            slider = me.slider,
+            style = {};
+
+        style[slider.vertical ? 'bottom' : 'left'] = slider.calculateThumbPosition(slider.normalizeValue(me.value)) + '%';
+        return {
+            style: style,
+            id  : this.id,
+            cls : this.cls
+        };
+    },
+
+    
+    move: function(v, animate) {
+        var el = this.el,
+            styleProp = this.slider.vertical ? 'bottom' : 'left',
+            to,
+            from;
+
+        v += '%';
+        
+        if (!animate) {
+            el.dom.style[styleProp] = v;
+        } else {
+            to = {};
+            to[styleProp] = v;
+            
+            if (!Ext.supports.GetPositionPercentage) {
+                from = {};
+                from[styleProp] = el.dom.style[styleProp];
+            }
+            
+            new Ext.fx.Anim({
+                target: el,
+                duration: 350,
+                from: from,
+                to: to
+            });
+        }
+    },
+
+    
+    bringToFront: function() {
+        this.el.setStyle('zIndex', this.topZIndex);
+    },
+
+    
+    sendToBack: function() {
+        this.el.setStyle('zIndex', '');
+    },
+
+    
+    enable: function() {
+        var me = this;
+
+        me.disabled = false;
+        if (me.el) {
+            me.el.removeCls(me.slider.disabledCls);
+        }
+    },
+
+    
+    disable: function() {
+        var me = this;
+
+        me.disabled = true;
+        if (me.el) {
+            me.el.addCls(me.slider.disabledCls);
+        }
+    },
+
+    
+    initEvents: function() {
+        var me = this,
+            el = me.el;
+
+        me.tracker = new Ext.dd.DragTracker({
+            onBeforeStart: Ext.Function.bind(me.onBeforeDragStart, me),
+            onStart      : Ext.Function.bind(me.onDragStart, me),
+            onDrag       : Ext.Function.bind(me.onDrag, me),
+            onEnd        : Ext.Function.bind(me.onDragEnd, me),
+            tolerance    : 3,
+            autoStart    : 300,
+            overCls      : Ext.baseCSSPrefix + 'slider-thumb-over'
+        });
+
+        me.tracker.initEl(el);
+    },
+
+    
+    onBeforeDragStart : function(e) {
+        if (this.disabled) {
+            return false;
+        } else {
+            this.slider.promoteThumb(this);
+            return true;
+        }
+    },
+
+    
+    onDragStart: function(e){
+        var me = this;
+
+        me.el.addCls(Ext.baseCSSPrefix + 'slider-thumb-drag');
+        me.dragging = me.slider.dragging = true;
+        me.dragStartValue = me.value;
+
+        me.slider.fireEvent('dragstart', me.slider, e, me);
+    },
+
+    
+    onDrag: function(e) {
+        var me       = this,
+            slider   = me.slider,
+            index    = me.index,
+            newValue = me.getValueFromTracker(),
+            above,
+            below;
+
+        
+        if (newValue !== undefined) {
+            if (me.constrain) {
+                above = slider.thumbs[index + 1];
+                below = slider.thumbs[index - 1];
+
+                if (below !== undefined && newValue <= below.value) {
+                    newValue = below.value;
+                }
+
+                if (above !== undefined && newValue >= above.value) {
+                    newValue = above.value;
+                }
+            }
+            slider.setValue(index, newValue, false);
+            slider.fireEvent('drag', slider, e, me);
+        }
+    },
+
+    getValueFromTracker: function() {
+        var slider = this.slider,
+            trackPoint = slider.getTrackpoint(this.tracker.getXY());
+
+        
+        if (trackPoint !== undefined) {
+            return slider.reversePixelValue(trackPoint);
+        }
+    },
+
+    
+    onDragEnd: function(e) {
+        var me     = this,
+            slider = me.slider,
+            value  = me.value;
+
+        me.el.removeCls(Ext.baseCSSPrefix + 'slider-thumb-drag');
+
+        me.dragging = slider.dragging = false;
+        slider.fireEvent('dragend', slider, e);
+
+        if (me.dragStartValue != value) {
+            slider.fireEvent('changecomplete', slider, value, me);
+        }
+    },
+
+    destroy: function() {
+        Ext.destroy(this.tracker);
+    }
+});
+
+
+Ext.define('Ext.slider.Tip', {
+    extend: 'Ext.tip.Tip',
+    minWidth: 10,
+    alias: 'widget.slidertip',
+    
+    
+    offsets : null,
+    
+    
+    align: null,
+    
+    
+    position: '',
+    
+    defaultVerticalPosition: 'left',
+    
+    defaultHorizontalPosition: 'top',
+
+    isSliderTip: true,
+
+    init: function(slider) {
+        var me = this,
+            align,
+            offsets;
+        
+        if (!me.position) {
+            me.position = slider.vertical ? me.defaultVerticalPosition : me.defaultHorizontalPosition;
+        }
+            
+        switch (me.position) {
+            case 'top':
+                offsets = [0, -10];
+                align = 'b-t?';
+                break;
+            case 'bottom':
+                offsets = [0, 10];
+                align = 't-b?';
+                break;
+            case 'left':
+                offsets = [-10, 0];
+                align = 'r-l?';
+                break;
+            case 'right':
+                offsets = [10, 0];
+                align = 'l-r?';
+        }
+        
+        if (!me.align) {
+            me.align = align;
+        }
+        
+        if (!me.offsets) {
+            me.offsets = offsets;
+        }
+
+        slider.on({
+            scope    : me,
+            dragstart: me.onSlide,
+            drag     : me.onSlide,
+            dragend  : me.hide,
+            destroy  : me.destroy
+        });
+    },
+    
+    onSlide : function(slider, e, thumb) {
+        var me = this;
+        me.show();
+        me.update(me.getText(thumb));
+        me.el.alignTo(thumb.el, me.align, me.offsets);
+    },
+
+    
+    getText : function(thumb) {
+        return String(thumb.value);
+    }
+});
+
+
+Ext.define('Ext.slider.Multi', {
+    extend: 'Ext.form.field.Base',
+    alias: 'widget.multislider',
+    alternateClassName: 'Ext.slider.MultiSlider',
+
+    requires: [
+        'Ext.slider.Thumb',
+        'Ext.slider.Tip',
+        'Ext.Number',
+        'Ext.util.Format',
+        'Ext.Template',
+        'Ext.layout.component.field.Slider'
+    ],
+
+    childEls: [
+        'endEl', 'innerEl'
+    ],
+
+    
+    fieldSubTpl: [
+        '<div id="{id}" class="' + Ext.baseCSSPrefix + 'slider {fieldCls} {vertical}" aria-valuemin="{minValue}" aria-valuemax="{maxValue}" aria-valuenow="{value}" aria-valuetext="{value}">',
+            '<div id="{cmpId}-endEl" class="' + Ext.baseCSSPrefix + 'slider-end" role="presentation">',
+                '<div id="{cmpId}-innerEl" class="' + Ext.baseCSSPrefix + 'slider-inner" role="presentation">',
+                    '{%this.renderThumbs(out, values)%}',
+                '</div>',
+            '</div>',
+        '</div>',
+        {
+            renderThumbs: function(out, values) {
+                var me = values.$comp,
+                    i = 0,
+                    thumbs = me.thumbs,
+                    len = thumbs.length,
+                    thumb,
+                    thumbConfig;
+
+                for (; i < len; i++) {
+                    thumb = thumbs[i];
+                    thumbConfig = thumb.getElConfig();
+                    thumbConfig.id = me.id + '-thumb-' + i;
+                    Ext.DomHelper.generateMarkup(thumbConfig, out);
+                }
+            },
+            disableFormats: true
+        }
+    ],
+
+    
+
+    
+
+    
+    vertical: false,
+
+    
+    minValue: 0,
+
+    
+    maxValue: 100,
+
+    
+    decimalPrecision: 0,
+
+    
+    keyIncrement: 1,
+
+    
+    increment: 0,
+
+    
+
+    
+    clickRange: [5,15],
+
+    
+    clickToChange : true,
+
+    
+    animate: true,
+
+    
+    dragging: false,
+
+    
+    constrainThumbs: true,
+
+    componentLayout: 'sliderfield',
+
+    
+    useTips : true,
+
+    
+    tipText : null,
+
+    ariaRole: 'slider',
+
+    
+    initValue: function() {
+        var me = this,
+            extValue = Ext.value,
+            
+            values = extValue(me.values, [extValue(me.value, extValue(me.minValue, 0))]),
+            i = 0,
+            len = values.length;
+
+        
+        me.originalValue = values;
+
+        
+        for (; i < len; i++) {
+            me.addThumb(values[i]);
+        }
+    },
+
+    
+    initComponent : function() {
+        var me = this,
+            tipPlug,
+            hasTip,
+            p, pLen, plugins;
+
+        
+        me.thumbs = [];
+
+        me.keyIncrement = Math.max(me.increment, me.keyIncrement);
+
+        me.addEvents(
+            
+            'beforechange',
+
+            
+            'change',
+
+            
+            'changecomplete',
+
+            
+            'dragstart',
+
+            
+            'drag',
+
+            
+            'dragend'
+        );
+
+        
+        if (me.increment) {
+            me.maxValue = Ext.Number.snapInRange(me.maxValue, me.increment, me.minValue);
+            me.value = me.normalizeValue(me.value);
+        }
+
+        me.callParent();
+
+        
+        if (me.useTips) {
+            if (Ext.isObject(me.useTips)) {
+                tipPlug = Ext.apply({}, me.useTips);
+            } else {
+                tipPlug = me.tipText ? {getText: me.tipText} : {};    
+            }
+
+            plugins = me.plugins = me.plugins || [];
+            pLen    = plugins.length;
+            
+            for (p = 0; p < pLen; p++) {
+                if (plugins[p].isSliderTip) {
+                    hasTip = true;
+                    break;
+                }
+            }
+
+            if (!hasTip) {
+                me.plugins.push(new Ext.slider.Tip(tipPlug));
+            }
+        }
+    },
+
+    
+    addThumb: function(value) {
+        var me = this,
+            thumb = new Ext.slider.Thumb({
+                ownerCt     : me,
+                ownerLayout : me.getComponentLayout(),
+                value       : value,
+                slider      : me,
+                index       : me.thumbs.length,
+                constrain   : me.constrainThumbs,
+                disabled    : !!me.readOnly
+            });
+
+        me.thumbs.push(thumb);
+
+        
+        if (me.rendered) {
+            thumb.render();
+        }
+
+        return thumb;
+    },
+
+    
+    promoteThumb: function(topThumb) {
+        var thumbs = this.thumbs,
+            ln = thumbs.length,
+            zIndex, thumb, i;
+
+        for (i = 0; i < ln; i++) {
+            thumb = thumbs[i];
+
+            if (thumb == topThumb) {
+                thumb.bringToFront();
+            } else {
+                thumb.sendToBack();
+            }
+        }
+    },
+
+    
+    getSubTplData : function() {
+        var me = this;
+
+        return Ext.apply(me.callParent(), {
+            $comp: me,
+            vertical: me.vertical ? Ext.baseCSSPrefix + 'slider-vert' : Ext.baseCSSPrefix + 'slider-horz',
+            minValue: me.minValue,
+            maxValue: me.maxValue,
+            value: me.value
+        });
+    },
+
+    onRender : function() {
+        var me = this,
+            thumbs = me.thumbs,
+            len = thumbs.length,
+            i = 0,
+            thumb;
+
+        me.callParent(arguments);
+
+        for (i = 0; i < len; i++) {
+            thumb = thumbs[i];
+            thumb.el = me.el.getById(me.id + '-thumb-' + i);
+            thumb.onRender();
+        }
+    },
+
+    
+    initEvents : function() {
+        var me = this;
+        me.mon(me.el, {
+            scope    : me,
+            mousedown: me.onMouseDown,
+            keydown  : me.onKeyDown
+        });
+    },
+
+    
+    getTrackpoint : function(xy) {
+        var me = this,
+            result,
+            positionProperty,
+            sliderTrack = me.innerEl,
+            trackLength;
+
+        if (me.vertical) {
+            positionProperty = 'top';
+            trackLength = sliderTrack.getHeight();
+        } else {
+            positionProperty = 'left';
+            trackLength = sliderTrack.getWidth();
+        }
+        result = Ext.Number.constrain(sliderTrack.translatePoints(xy)[positionProperty], 0, trackLength);
+        return me.vertical ? trackLength - result : result;
+    },
+
+    
+    onMouseDown : function(e) {
+        var me = this,
+            thumbClicked = false,
+            i = 0,
+            thumbs = me.thumbs,
+            len = thumbs.length,
+            trackPoint;
+
+        if (me.disabled) {
+            return;
+        }
+
+        
+        for (; i < len; i++) {
+            thumbClicked = thumbClicked || e.target == thumbs[i].el.dom;
+        }
+
+        if (me.clickToChange && !thumbClicked) {
+            trackPoint = me.getTrackpoint(e.getXY());
+            if (trackPoint !== undefined) {
+                me.onClickChange(trackPoint);
+            }
+        }
+        me.focus();
+    },
+
+    
+    onClickChange : function(trackPoint) {
+        var me = this,
+            thumb, index;
+
+        
+        
+
+        
+        thumb = me.getNearest(trackPoint);
+        if (!thumb.disabled) {
+            index = thumb.index;
+            me.setValue(index, Ext.util.Format.round(me.reversePixelValue(trackPoint), me.decimalPrecision), undefined, true);
+        }
+    },
+
+    
+    getNearest: function(trackPoint) {
+        var me = this,
+            clickValue = me.reversePixelValue(trackPoint),
+            nearestDistance = (me.maxValue - me.minValue) + 5, 
+            nearest = null,
+            thumbs = me.thumbs,
+            i = 0,
+            len = thumbs.length,
+            thumb,
+            value,
+            dist;
+
+        for (; i < len; i++) {
+            thumb = me.thumbs[i];
+            value = thumb.value;
+            dist  = Math.abs(value - clickValue);
+
+            if (Math.abs(dist <= nearestDistance)) {
+                nearest = thumb;
+                nearestDistance = dist;
+            }
+        }
+        return nearest;
+    },
+
+    
+    onKeyDown : function(e) {
+        
+        var me = this,
+            k,
+            val;
+
+        if(me.disabled || me.thumbs.length !== 1) {
+            e.preventDefault();
+            return;
+        }
+        k = e.getKey();
+
+        switch(k) {
+            case e.UP:
+            case e.RIGHT:
+                e.stopEvent();
+                val = e.ctrlKey ? me.maxValue : me.getValue(0) + me.keyIncrement;
+                me.setValue(0, val, undefined, true);
+            break;
+            case e.DOWN:
+            case e.LEFT:
+                e.stopEvent();
+                val = e.ctrlKey ? me.minValue : me.getValue(0) - me.keyIncrement;
+                me.setValue(0, val, undefined, true);
+            break;
+            default:
+                e.preventDefault();
+        }
+    },
+
+    
+    normalizeValue : function(v) {
+        var me = this,
+            Num = Ext.Number,
+            snapFn = Num[me.zeroBasedSnapping ? 'snap' : 'snapInRange'];
+
+        v = snapFn.call(Num, v, me.increment, me.minValue, me.maxValue);
+        v = Ext.util.Format.round(v, me.decimalPrecision);
+        v = Ext.Number.constrain(v, me.minValue, me.maxValue);
+        return v;
+    },
+
+    
+    setMinValue : function(val) {
+        var me = this,
+            i = 0,
+            thumbs = me.thumbs,
+            len = thumbs.length,
+            t;
+
+        me.minValue = val;
+        if (me.rendered) {
+            me.inputEl.dom.setAttribute('aria-valuemin', val);
+        }
+
+        for (; i < len; ++i) {
+            t = thumbs[i];
+            t.value = t.value < val ? val : t.value;
+        }
+        me.syncThumbs();
+    },
+
+    
+    setMaxValue : function(val) {
+        var me = this,
+            i = 0,
+            thumbs = me.thumbs,
+            len = thumbs.length,
+            t;
+
+        me.maxValue = val;
+        if (me.rendered) {
+            me.inputEl.dom.setAttribute('aria-valuemax', val);
+        }
+
+        for (; i < len; ++i) {
+            t = thumbs[i];
+            t.value = t.value > val ? val : t.value;
+        }
+        me.syncThumbs();
+    },
+
+    
+    setValue : function(index, value, animate, changeComplete) {
+        var me = this,
+            thumb = me.thumbs[index];
+
+        
+        value = me.normalizeValue(value);
+
+        if (value !== thumb.value && me.fireEvent('beforechange', me, value, thumb.value, thumb) !== false) {
+            thumb.value = value;
+            if (me.rendered) {
+                
+                
+                me.inputEl.set({
+                    'aria-valuenow': value,
+                    'aria-valuetext': value
+                });
+
+                thumb.move(me.calculateThumbPosition(value), Ext.isDefined(animate) ? animate !== false : me.animate);
+
+                me.fireEvent('change', me, value, thumb);
+                me.checkDirty();
+                if (changeComplete) {
+                    me.fireEvent('changecomplete', me, value, thumb);
+                }
+            }
+        }
+    },
+
+    
+    calculateThumbPosition : function(v) {
+        return (v - this.minValue) / (this.maxValue - this.minValue) * 100;
+    },
+
+    
+    getRatio : function() {
+        var me = this,
+            trackLength = this.vertical ? this.innerEl.getHeight() : this.innerEl.getWidth(),
+            valueRange = this.maxValue - this.minValue;
+        return valueRange === 0 ? trackLength : (trackLength / valueRange);
+    },
+
+    
+    reversePixelValue : function(pos) {
+        return this.minValue + (pos / this.getRatio());
+    },
+
+    
+    reversePercentageValue : function(pos) {
+        return this.minValue + (this.maxValue - this.minValue) * (pos / 100);
+    },
+
+    
+    onDisable: function() {
+        var me = this,
+            i = 0,
+            thumbs = me.thumbs,
+            len = thumbs.length,
+            thumb,
+            el,
+            xy;
+
+        me.callParent();
+
+        for (; i < len; i++) {
+            thumb = thumbs[i];
+            el = thumb.el;
+
+            thumb.disable();
+
+            if(Ext.isIE) {
+                
+                
+                xy = el.getXY();
+                el.hide();
+
+                me.innerEl.addCls(me.disabledCls).dom.disabled = true;
+
+                if (!me.thumbHolder) {
+                    me.thumbHolder = me.endEl.createChild({cls: Ext.baseCSSPrefix + 'slider-thumb ' + me.disabledCls});
+                }
+
+                me.thumbHolder.show().setXY(xy);
+            }
+        }
+    },
+
+    
+    onEnable: function() {
+        var me = this,
+            i = 0,
+            thumbs = me.thumbs,
+            len = thumbs.length,
+            thumb,
+            el;
+
+        this.callParent();
+
+        for (; i < len; i++) {
+            thumb = thumbs[i];
+            el = thumb.el;
+
+            thumb.enable();
+
+            if (Ext.isIE) {
+                me.innerEl.removeCls(me.disabledCls).dom.disabled = false;
+
+                if (me.thumbHolder) {
+                    me.thumbHolder.hide();
+                }
+
+                el.show();
+                me.syncThumbs();
+            }
+        }
+    },
+
+    
+    syncThumbs : function() {
+        if (this.rendered) {
+            var thumbs = this.thumbs,
+                length = thumbs.length,
+                i = 0;
+
+            for (; i < length; i++) {
+                thumbs[i].move(this.calculateThumbPosition(thumbs[i].value));
+            }
+        }
+    },
+
+    
+    getValue : function(index) {
+        return Ext.isNumber(index) ? this.thumbs[index].value : this.getValues();
+    },
+
+    
+    getValues: function() {
+        var values = [],
+            i = 0,
+            thumbs = this.thumbs,
+            len = thumbs.length;
+
+        for (; i < len; i++) {
+            values.push(thumbs[i].value);
+        }
+
+        return values;
+    },
+
+    getSubmitValue: function() {
+        var me = this;
+        return (me.disabled || !me.submitValue) ? null : me.getValue();
+    },
+
+    reset: function() {
+        var me = this,
+            arr = [].concat(me.originalValue),
+            a     = 0,
+            aLen  = arr.length,
+            val;
+
+        for (; a < aLen; a++) {
+            val = arr[a];
+
+            me.setValue(a, val);
+        }
+
+        me.clearInvalid();
+        
+        delete me.wasValid;
+    },
+    
+    setReadOnly: function(readOnly){
+        var me = this,
+            thumbs = me.thumbs,
+            len = thumbs.length,
+            i = 0;
+            
+        me.callParent(arguments); 
+        readOnly = me.readOnly;
+        
+        for (; i < len; ++i) {
+            if (readOnly) {
+                thumbs[i].disable();
+            } else {
+                thumbs[i].enable();
+            }
+            
+        }
+           
+    },
+
+    
+    beforeDestroy : function() {
+        var me     = this,
+            thumbs = me.thumbs,
+            t      = 0,
+            tLen   = thumbs.length,
+            thumb;
+
+        Ext.destroy(me.innerEl, me.endEl, me.focusEl);
+
+        for (; t < tLen; t++) {
+            thumb = thumbs[t];
+
+            Ext.destroy(thumb);
+        }
+
+        me.callParent();
+    }
+});
+
+
+Ext.define('Ext.slider.Single', {
+    extend: 'Ext.slider.Multi',
+    alias: ['widget.slider', 'widget.sliderfield'],
+    alternateClassName: ['Ext.Slider', 'Ext.form.SliderField', 'Ext.slider.SingleSlider', 'Ext.slider.Slider'],
+
+    
+    getValue: function() {
+        
+        return this.callParent([0]);
+    },
+
+    
+    setValue: function(value, animate) {
+        var args = arguments,
+            len  = args.length;
+
+        
+        
+        
+        if (len == 1 || (len <= 3 && typeof args[1] != 'number')) {
+            args = Ext.toArray(args);
+            args.unshift(0);
+        }
+        return this.callParent(args);
+    },
+
+    
+    getNearest : function(){
+        
+        return this.thumbs[0];
+    }
+});
+
+
+Ext.define('Ext.state.CookieProvider', {
+    extend: 'Ext.state.Provider',
+
+    
+
+    
+
+    
+
+    
+
+    
+    constructor : function(config){
+        var me = this;
+        me.path = "/";
+        me.expires = new Date(new Date().getTime()+(1000*60*60*24*7)); 
+        me.domain = null;
+        me.secure = false;
+        me.callParent(arguments);
+        me.state = me.readCookies();
+    },
+
+    
+    set : function(name, value){
+        var me = this;
+
+        if(typeof value == "undefined" || value === null){
+            me.clear(name);
+            return;
+        }
+        me.setCookie(name, value);
+        me.callParent(arguments);
+    },
+
+    
+    clear : function(name){
+        this.clearCookie(name);
+        this.callParent(arguments);
+    },
+
+    
+    readCookies : function(){
+        var cookies = {},
+            c = document.cookie + ";",
+            re = /\s?(.*?)=(.*?);/g,
+            prefix = this.prefix,
+            len = prefix.length,
+            matches,
+            name,
+            value;
+
+        while((matches = re.exec(c)) != null){
+            name = matches[1];
+            value = matches[2];
+            if (name && name.substring(0, len) == prefix){
+                cookies[name.substr(len)] = this.decodeValue(value);
+            }
+        }
+        return cookies;
+    },
+
+    
+    setCookie : function(name, value){
+        var me = this;
+
+        document.cookie = me.prefix + name + "=" + me.encodeValue(value) +
+           ((me.expires == null) ? "" : ("; expires=" + me.expires.toGMTString())) +
+           ((me.path == null) ? "" : ("; path=" + me.path)) +
+           ((me.domain == null) ? "" : ("; domain=" + me.domain)) +
+           ((me.secure == true) ? "; secure" : "");
+    },
+
+    
+    clearCookie : function(name){
+        var me = this;
+
+        document.cookie = me.prefix + name + "=null; expires=Thu, 01-Jan-70 00:00:01 GMT" +
+           ((me.path == null) ? "" : ("; path=" + me.path)) +
+           ((me.domain == null) ? "" : ("; domain=" + me.domain)) +
+           ((me.secure == true) ? "; secure" : "");
+    }
+});
+
+
+
+Ext.define('Ext.state.LocalStorageProvider', {
+    
+    
+    extend: 'Ext.state.Provider',
+    
+    alias: 'state.localstorage',
+    
+    
+   
+    constructor: function(){
+        var me = this;
+        me.callParent(arguments);
+        me.store = me.getStorageObject();
+        me.state = me.readLocalStorage();
+    },
+    
+    readLocalStorage: function(){
+        var store = this.store,
+            i = 0,
+            len = store.length,
+            prefix = this.prefix,
+            prefixLen = prefix.length,
+            data = {},
+            key;
+            
+        for (; i < len; ++i) {
+            key = store.key(i);
+            if (key.substring(0, prefixLen) == prefix) {
+                data[key.substr(prefixLen)] = this.decodeValue(store.getItem(key));
+            }            
+        }
+        return data;
+    },
+    
+    set : function(name, value){
+        var me = this;
+        
+        me.clear(name);
+        if (typeof value == "undefined" || value === null) {
+            return;
+        }
+        me.store.setItem(me.prefix + name, me.encodeValue(value));
+        me.callParent(arguments);
+    },
+
+    
+    clear : function(name){
+        this.store.removeItem(this.prefix + name);
+        this.callParent(arguments);
+    },
+    
+    getStorageObject: function(){
+        try {
+            var supports = 'localStorage' in window && window['localStorage'] !== null;
+            if (supports) {
+                return window.localStorage;
+            }
+        } catch (e) {
+            return false;
+        }
+    }    
+});
+
+
+Ext.define('Ext.tab.Tab', {
+    extend: 'Ext.button.Button',
+    alias: 'widget.tab',
+
+    requires: [
+        'Ext.layout.component.Tab',
+        'Ext.util.KeyNav'
+    ],
+
+    componentLayout: 'tab',
+
+    
+    isTab: true,
+
+    baseCls: Ext.baseCSSPrefix + 'tab',
+
+    
+    activeCls: 'active',
+
+    
+
+    
+    closableCls: 'closable',
+
+    
+    closable: true,
+
+    
+    
+    closeText: 'Close Tab',
+    
+
+    
+    active: false,
+
+    
+
+    childEls: [
+        'closeEl'
+    ],
+
+    scale: false,
+
+    position: 'top',
+
+    initComponent: function() {
+        var me = this;
+
+        me.addEvents(
+            
+            'activate',
+
+            
+            'deactivate',
+
+            
+            'beforeclose',
+
+            
+            'close'
+        );
+
+        me.callParent(arguments);
+
+        if (me.card) {
+            me.setCard(me.card);
+        }
+    },
+
+    getTemplateArgs: function() {
+        var me = this,
+            result = me.callParent();
+
+        result.closable = me.closable;
+        result.closeText = me.closeText;
+
+        return result;
+    },
+
+    beforeRender: function() {
+        var me = this,
+            tabBar = me.up('tabbar'),
+            tabPanel = me.up('tabpanel');
+        
+        me.callParent();
+        
+        me.addClsWithUI(me.position);
+
+        
+        
+
+        me.syncClosableUI();
+
+        
+        if (!me.minWidth) {
+            me.minWidth = (tabBar) ? tabBar.minTabWidth : me.minWidth;
+            if (!me.minWidth && tabPanel) {
+                me.minWidth = tabPanel.minTabWidth;
+            }
+            if (me.minWidth && me.iconCls) {
+                me.minWidth += 25;
+            }
+        }
+        if (!me.maxWidth) {
+            me.maxWidth = (tabBar) ? tabBar.maxTabWidth : me.maxWidth;
+            if (!me.maxWidth && tabPanel) {
+                me.maxWidth = tabPanel.maxTabWidth;
+            }
+        }
+    },
+
+    onRender: function() {
+        var me = this;
+
+        me.callParent(arguments);
+
+        me.keyNav = new Ext.util.KeyNav(me.el, {
+            enter: me.onEnterKey,
+            del: me.onDeleteKey,
+            scope: me
+        });
+    },
+
+    
+    enable : function(silent) {
+        var me = this;
+
+        me.callParent(arguments);
+
+        me.removeClsWithUI(me.position + '-disabled');
+
+        return me;
+    },
+
+    
+    disable : function(silent) {
+        var me = this;
+
+        me.callParent(arguments);
+
+        me.addClsWithUI(me.position + '-disabled');
+
+        return me;
+    },
+
+    onDestroy: function() {
+        var me = this;
+
+        Ext.destroy(me.keyNav);
+        delete me.keyNav;
+
+        me.callParent(arguments);
+    },
+
+    
+    setClosable: function(closable) {
+        var me = this;
+
+        
+        closable = (!arguments.length || !!closable);
+
+        if (me.closable != closable) {
+            me.closable = closable;
+
+            
+            if (me.card) {
+                me.card.closable = closable;
+            }
+
+            me.syncClosableUI();
+
+            if (me.rendered) {
+                me.syncClosableElements();
+
+                
+                me.updateLayout();
+            }
+        }
+    },
+
+    
+    syncClosableElements: function () {
+        var me = this,
+            closeEl = me.closeEl;
+
+        if (me.closable) {
+            if (!closeEl) {
+                me.closeEl = me.btnWrap.insertSibling({
+                    tag: 'a',
+                    cls: me.baseCls + '-close-btn',
+                    href: '#',
+                    title: me.closeText
+                }, 'after');
+            }
+        } else if (closeEl) {
+            closeEl.remove();
+            delete me.closeEl;
+        }
+    },
+
+    
+    syncClosableUI: function () {
+        var me = this,
+            classes = [me.closableCls, me.closableCls + '-' + me.position];
+
+        if (me.closable) {
+            me.addClsWithUI(classes);
+        } else {
+            me.removeClsWithUI(classes);
+        }
+    },
+
+    
+    setCard: function(card) {
+        var me = this;
+
+        me.card = card;
+        me.setText(me.title || card.title);
+        me.setIconCls(me.iconCls || card.iconCls);
+        me.setIcon(me.icon || card.icon);
+    },
+
+    
+    onCloseClick: function() {
+        var me = this;
+
+        if (me.fireEvent('beforeclose', me) !== false) {
+            if (me.tabBar) {
+                if (me.tabBar.closeTab(me) === false) {
+                    
+                    return;
+                }
+            } else {
+                
+                me.fireClose();
+            }
+        }
+    },
+
+    
+    fireClose: function(){
+        this.fireEvent('close', this);
+    },
+
+    
+    onEnterKey: function(e) {
+        var me = this;
+
+        if (me.tabBar) {
+            me.tabBar.onClick(e, me.el);
+        }
+    },
+
+   
+    onDeleteKey: function(e) {
+        if (this.closable) {
+            this.onCloseClick();
+        }
+    },
+
+    
+    activate : function(supressEvent) {
+        var me = this;
+
+        me.active = true;
+        me.addClsWithUI([me.activeCls, me.position + '-' + me.activeCls]);
+
+        if (supressEvent !== true) {
+            me.fireEvent('activate', me);
+        }
+    },
+
+    
+    deactivate : function(supressEvent) {
+        var me = this;
+
+        me.active = false;
+        me.removeClsWithUI([me.activeCls, me.position + '-' + me.activeCls]);
+
+        if (supressEvent !== true) {
+            me.fireEvent('deactivate', me);
+        }
+    }
+});
+
+
+Ext.define('Ext.tab.Bar', {
+    extend: 'Ext.panel.Header',
+    alias: 'widget.tabbar',
+    baseCls: Ext.baseCSSPrefix + 'tab-bar',
+
+    requires: ['Ext.tab.Tab'],
+
+    
+    isTabBar: true,
+    
+    
+    
+    
+
+    
+    defaultType: 'tab',
+
+    
+    plain: false,
+
+    childEls: [
+        'body', 'strip'
+    ],
+
+    
+    renderTpl: [
+        '<div id="{id}-body" class="{baseCls}-body {bodyCls}<tpl if="ui"> {baseCls}-body-{ui}<tpl for="uiCls"> {parent.baseCls}-body-{parent.ui}-{.}</tpl></tpl>"<tpl if="bodyStyle"> style="{bodyStyle}"</tpl>>',
+            '{%this.renderContainer(out,values)%}',
+        '</div>',
+        '<div id="{id}-strip" class="{baseCls}-strip<tpl if="ui"> {baseCls}-strip-{ui}<tpl for="uiCls"> {parent.baseCls}-strip-{parent.ui}-{.}</tpl></tpl>"></div>'
+    ],
+
+    
+
+    
+
+    
+    initComponent: function() {
+        var me = this;
+
+        if (me.plain) {
+            me.setUI(me.ui + '-plain');
+        }
+
+        me.addClsWithUI(me.dock);
+
+        me.addEvents(
+            
+            'change'
+        );
+
+        
+        me.callParent(arguments);
+
+        
+        me.layout.align = (me.orientation == 'vertical') ? 'left' : 'top';
+        me.layout.overflowHandler = new Ext.layout.container.boxOverflow.Scroller(me.layout);
+
+        me.remove(me.titleCmp);
+        delete me.titleCmp;
+
+        Ext.apply(me.renderData, {
+            bodyCls: me.bodyCls
+        });
+    },
+
+    getLayout: function() {
+        var me = this;
+        me.layout.type = (me.dock === 'top' || me.dock === 'bottom') ? 'hbox' : 'vbox';
+        return me.callParent(arguments);
+    },
+
+    
+    onAdd: function(tab) {
+        tab.position = this.dock;
+        this.callParent(arguments);
+    },
+    
+    onRemove: function(tab) {
+        var me = this;
+        
+        if (tab === me.previousTab) {
+            me.previousTab = null;
+        }
+        me.callParent(arguments);    
+    },
+
+    afterComponentLayout : function(width) {
+        this.callParent(arguments);
+        this.strip.setWidth(width);
+    },
+
+    
+    onClick: function(e, target) {
+        
+        var me = this,
+            tabEl = e.getTarget('.' + Ext.tab.Tab.prototype.baseCls),
+            tab = tabEl && Ext.getCmp(tabEl.id),
+            tabPanel = me.tabPanel,
+            isCloseClick = tab && tab.closeEl && (target === tab.closeEl.dom);
+
+        if (isCloseClick) {
+            e.preventDefault();
+        }
+        if (tab && tab.isDisabled && !tab.isDisabled()) {
+            if (tab.closable && isCloseClick) {
+                tab.onCloseClick();
+            } else {
+                if (tabPanel) {
+                    
+                    tabPanel.setActiveTab(tab.card);
+                } else {
+                    me.setActiveTab(tab);
+                }
+                tab.focus();
+            }
+        }
+    },
+
+    
+    closeTab: function(toClose) {
+        var me = this,
+            card = toClose.card,
+            tabPanel = me.tabPanel,
+            toActivate;
+
+        if (card && card.fireEvent('beforeclose', card) === false) {
+            return false;
+        }
+        
+        
+        
+        
+        toActivate = me.findNextActivatable(toClose);
+
+        
+        
+        Ext.suspendLayouts();
+
+        if (tabPanel && card) {
+            
+            
+            delete toClose.ownerCt;
+            
+            
+            
+            card.fireEvent('close', card);
+            tabPanel.remove(card);
+            
+            
+            if (!tabPanel.getComponent(card)) {
+                
+                toClose.fireClose();
+                me.remove(toClose);
+            } else {
+                
+                toClose.ownerCt = me;
+                Ext.resumeLayouts(true);
+                return false;
+            }
+        }
+
+        
+        if (toActivate) {
+            
+            
+            if (tabPanel) {
+                tabPanel.setActiveTab(toActivate.card);
+            } else {
+                me.setActiveTab(toActivate);
+            }
+            toActivate.focus();
+        }
+        Ext.resumeLayouts(true);
+    },
+
+    
+    
+    findNextActivatable: function(toClose) {
+        var me = this;
+        if (toClose.active && me.items.getCount() > 1) {
+            return (me.previousTab && me.previousTab !== toClose && !me.previousTab.disabled) ? me.previousTab : (toClose.next('tab[disabled=false]') || toClose.prev('tab[disabled=false]'));
+        }
+    },
+
+    
+    setActiveTab: function(tab) {
+        var me = this;
+
+        if (!tab.disabled && tab !== me.activeTab) {
+            if (me.activeTab) {
+                if (me.activeTab.isDestroyed) {
+                    me.previousTab = null;
+                } else {
+                    me.previousTab = me.activeTab;
+                    me.activeTab.deactivate();
+                }
+            }
+            tab.activate();
+
+            me.activeTab = tab;
+            me.fireEvent('change', me, tab, tab.card);
+
+            
+            me.on({
+                afterlayout: me.afterTabActivate,
+                scope: me,
+                single: true
+            });
+            me.updateLayout();
+        }
+    },
+
+    afterTabActivate: function() {
+        this.layout.overflowHandler.scrollToItem(this.activeTab);
+    }
+});
+
+
+Ext.define('Ext.tab.Panel', {
+    extend: 'Ext.panel.Panel',
+    alias: 'widget.tabpanel',
+    alternateClassName: ['Ext.TabPanel'],
+
+    requires: ['Ext.layout.container.Card', 'Ext.tab.Bar'],
+
+    
+    tabPosition : 'top',
+
+    
+
+    
+
+    
+
+    
+
+    
+    removePanelHeader: true,
+
+    
+    plain: false,
+
+    
+    itemCls: Ext.baseCSSPrefix + 'tabpanel-child',
+
+    
+    minTabWidth: undefined,
+
+    
+    maxTabWidth: undefined,
+
+    
+    deferredRender : true,
+
+    
+    initComponent: function() {
+        var me = this,
+            dockedItems = [].concat(me.dockedItems || []),
+            activeTab = me.activeTab || (me.activeTab = 0);
+
+        
+        me.layout = new Ext.layout.container.Card(Ext.apply({
+            owner: me,
+            deferredRender: me.deferredRender,
+            itemCls: me.itemCls,
+            activeItem: me.activeTab
+        }, me.layout));
+
+        
+        me.tabBar = new Ext.tab.Bar(Ext.apply({
+            dock: me.tabPosition,
+            plain: me.plain,
+            border: me.border,
+            cardLayout: me.layout,
+            tabPanel: me
+        }, me.tabBar));
+
+        dockedItems.push(me.tabBar);
+        me.dockedItems = dockedItems;
+
+        me.addEvents(
+            
+            'beforetabchange',
+
+            
+            'tabchange'
+        );
+
+        me.callParent(arguments);
+
+        
+        me.activeTab = me.getComponent(activeTab);
+
+        
+        if (me.activeTab) {
+            me.activeTab.tab.activate(true);
+
+            
+            me.tabBar.activeTab = me.activeTab.tab;
+        }
+    },
+
+    
+    setActiveTab: function(card) {
+        var me = this,
+            previous;
+
+        card = me.getComponent(card);
+        if (card) {
+            previous = me.getActiveTab();
+
+            if (previous !== card && me.fireEvent('beforetabchange', me, card, previous) === false) {
+                return false;
+            }
+
+            
+            
+            if (!card.isComponent) {
+                Ext.suspendLayouts();
+                card = me.add(card);
+                Ext.resumeLayouts();
+            }
+
+            
+            
+            me.activeTab = card;
+
+            
+            
+            
+            Ext.suspendLayouts();
+            me.layout.setActiveItem(card);
+
+            
+            card = me.activeTab = me.layout.getActiveItem();
+
+            
+            if (card && card !== previous) {
+
+                
+                me.tabBar.setActiveTab(card.tab);
+                Ext.resumeLayouts(true);
+
+                
+                if (previous !== card) {
+                    me.fireEvent('tabchange', me, card, previous);
+                }
+            }
+            
+            else {
+                Ext.resumeLayouts(true);
+            }
+            return card;
+        }
+    },
+
+    
+    getActiveTab: function() {
+        var me = this,
+            
+            result = me.getComponent(me.activeTab);
+
+        
+        if (result && me.items.indexOf(result) != -1) {
+            me.activeTab = result;
+        } else {
+            me.activeTab = null;
+        }
+
+        return me.activeTab;
+    },
+
+    
+    getTabBar: function() {
+        return this.tabBar;
+    },
+
+    
+    onAdd: function(item, index) {
+        var me = this,
+            cfg = item.tabConfig || {},
+            defaultConfig = {
+                xtype: 'tab',
+                card: item,
+                disabled: item.disabled,
+                closable: item.closable,
+                hidden: item.hidden && !item.hiddenByLayout, 
+                tooltip: item.tooltip,
+                tabBar: me.tabBar,
+                closeText: item.closeText
+            };
+
+        cfg = Ext.applyIf(cfg, defaultConfig);
+
+        
+        item.tab = me.tabBar.insert(index, cfg);
+
+        item.on({
+            scope : me,
+            enable: me.onItemEnable,
+            disable: me.onItemDisable,
+            beforeshow: me.onItemBeforeShow,
+            iconchange: me.onItemIconChange,
+            iconclschange: me.onItemIconClsChange,
+            titlechange: me.onItemTitleChange
+        });
+
+        if (item.isPanel) {
+            if (me.removePanelHeader) {
+                if (item.rendered) {
+                    if (item.header) {
+                        item.header.hide();
+                    }
+                } else {
+                    item.header = false;
+                }
+            }
+            if (item.isPanel && me.border) {
+                item.setBorder(false);
+            }
+        }
+    },
+
+    
+    onItemEnable: function(item){
+        item.tab.enable();
+    },
+
+    
+    onItemDisable: function(item){
+        item.tab.disable();
+    },
+
+    
+    onItemBeforeShow: function(item) {
+        if (item !== this.activeTab) {
+            this.setActiveTab(item);
+            return false;
+        }
+    },
+
+    
+    onItemIconChange: function(item, newIcon) {
+        item.tab.setIcon(newIcon);
+    },
+    
+    
+    onItemIconClsChange: function(item, newIconCls) {
+        item.tab.setIconCls(newIconCls);
+    },
+
+    
+    onItemTitleChange: function(item, newTitle) {
+        item.tab.setText(newTitle);
+    },
+
+    
+    doRemove: function(item, autoDestroy) {
+        var me = this,
+            toActivate;
+
+        
+        if (me.destroying || me.items.getCount() == 1) {
+            me.activeTab = null;
+        }
+
+        
+        
+        else if ((toActivate = me.tabBar.items.indexOf(me.tabBar.findNextActivatable(item.tab))) !== -1) {
+             me.setActiveTab(toActivate);
+        }
+        this.callParent(arguments);
+
+        
+        delete item.tab.card;
+        delete item.tab;
+    },
+
+    
+    onRemove: function(item, destroying) {
+        var me = this;
+
+        item.un({
+            scope : me,
+            enable: me.onItemEnable,
+            disable: me.onItemDisable,
+            beforeshow: me.onItemBeforeShow
+        });
+        if (!me.destroying && item.tab.ownerCt === me.tabBar) {
+            me.tabBar.remove(item.tab);
+        }
+    }
+});
+
+
+Ext.define('Ext.toolbar.Spacer', {
+    extend: 'Ext.Component',
+    alias: 'widget.tbspacer',
+    alternateClassName: 'Ext.Toolbar.Spacer',
+    baseCls: Ext.baseCSSPrefix + 'toolbar-spacer',
+    focusable: false
+});
+
+
+Ext.define('Ext.tree.Column', {
+    extend: 'Ext.grid.column.Column',
+    alias: 'widget.treecolumn',
+
+    tdCls: Ext.baseCSSPrefix + 'grid-cell-treecolumn',
+    
+    treePrefix: Ext.baseCSSPrefix + 'tree-',
+    elbowPrefix: Ext.baseCSSPrefix + 'tree-elbow-',
+    expanderCls: Ext.baseCSSPrefix + 'tree-expander',
+    imgText: '<img src="{1}" class="{0}" />',
+    checkboxText: '<input type="button" role="checkbox" class="{0}" {1} />',
+
+    initComponent: function() {
+        var me = this;
+        
+        me.origRenderer = me.renderer || me.defaultRenderer;
+        me.origScope = me.scope || window;
+
+        me.renderer = me.treeRenderer;
+        me.scope = me;
+        
+        me.callParent();
+    },
+    
+    treeRenderer: function(value, metaData, record, rowIdx, colIdx, store, view){
+        var me = this,
+            buf = [],
+            format = Ext.String.format,
+            depth = record.getDepth(),
+            treePrefix  = me.treePrefix,
+            elbowPrefix = me.elbowPrefix,
+            expanderCls = me.expanderCls,
+            imgText     = me.imgText,
+            checkboxText= me.checkboxText,
+            formattedValue = me.origRenderer.apply(me.origScope, arguments),
+            blank = Ext.BLANK_IMAGE_URL,
+            href = record.get('href'),
+            target = record.get('hrefTarget'),
+            cls = record.get('cls');
+
+        while (record) {
+            if (!record.isRoot() || (record.isRoot() && view.rootVisible)) {
+                if (record.getDepth() === depth) {
+                    buf.unshift(format(imgText,
+                        treePrefix + 'icon ' + 
+                        treePrefix + 'icon' + (record.get('icon') ? '-inline ' : (record.isLeaf() ? '-leaf ' : '-parent ')) +
+                        (record.get('iconCls') || ''),
+                        record.get('icon') || blank
+                    ));
+                    if (record.get('checked') !== null) {
+                        buf.unshift(format(
+                            checkboxText,
+                            (treePrefix + 'checkbox') + (record.get('checked') ? ' ' + treePrefix + 'checkbox-checked' : ''),
+                            record.get('checked') ? 'aria-checked="true"' : ''
+                        ));
+                        if (record.get('checked')) {
+                            metaData.tdCls += (' ' + treePrefix + 'checked');
+                        }
+                    }
+                    if (record.isLast()) {
+                        if (record.isExpandable()) {
+                            buf.unshift(format(imgText, (elbowPrefix + 'end-plus ' + expanderCls), blank));
+                        } else {
+                            buf.unshift(format(imgText, (elbowPrefix + 'end'), blank));
+                        }
+                            
+                    } else {
+                        if (record.isExpandable()) {
+                            buf.unshift(format(imgText, (elbowPrefix + 'plus ' + expanderCls), blank));
+                        } else {
+                            buf.unshift(format(imgText, (treePrefix + 'elbow'), blank));
+                        }
+                    }
+                } else {
+                    if (record.isLast() || record.getDepth() === 0) {
+                        buf.unshift(format(imgText, (elbowPrefix + 'empty'), blank));
+                    } else if (record.getDepth() !== 0) {
+                        buf.unshift(format(imgText, (elbowPrefix + 'line'), blank));
+                    }                      
+                }
+            }
+            record = record.parentNode;
+        }
+        if (href) {
+            buf.push('<a href="', href, '" target="', target, '">', formattedValue, '</a>');
+        } else {
+            buf.push(formattedValue);
+        }
+        if (cls) {
+            metaData.tdCls += ' ' + cls;
+        }
+        return buf.join('');
+    },
+
+    defaultRenderer: function(value) {
+        return value;
+    }
+});
+
+
+Ext.define('Ext.tree.View', {
+    extend: 'Ext.view.Table',
+    alias: 'widget.treeview',
+
+    requires: [
+        'Ext.data.NodeStore'
+    ],
+
+    loadingCls: Ext.baseCSSPrefix + 'grid-tree-loading',
+    expandedCls: Ext.baseCSSPrefix + 'grid-tree-node-expanded',
+    leafCls: Ext.baseCSSPrefix + 'grid-tree-node-leaf',
+
+    expanderSelector: '.' + Ext.baseCSSPrefix + 'tree-expander',
+    checkboxSelector: '.' + Ext.baseCSSPrefix + 'tree-checkbox',
+    expanderIconOverCls: Ext.baseCSSPrefix + 'tree-expander-over',
+
+    
+    
+    
+    nodeAnimWrapCls: Ext.baseCSSPrefix + 'tree-animator-wrap',
+
+    blockRefresh: true,
+    
+    
+    loadMask: false,
+
+    
+    rootVisible: true,
+
+    
+    deferInitialRefresh: false,
+
+    
+
+    expandDuration: 250,
+    collapseDuration: 250,
+
+    toggleOnDblClick: true,
+
+    stripeRows: false,
+
+    
+    uiFields: ['expanded', 'loaded', 'checked', 'expandable', 'leaf', 'icon', 'iconCls', 'loading', 'qtip', 'qtitle'],
+
+    initComponent: function() {
+        var me = this,
+            treeStore = me.panel.getStore();
+
+        if (me.initialConfig.animate === undefined) {
+            me.animate = Ext.enableFx;
+        }
+
+        me.store = new Ext.data.NodeStore({
+            treeStore: treeStore,
+            recursive: true,
+            rootVisible: me.rootVisible,
+            listeners: {
+                beforeexpand: me.onBeforeExpand,
+                expand: me.onExpand,
+                beforecollapse: me.onBeforeCollapse,
+                collapse: me.onCollapse,
+                write: me.onStoreWrite,
+                datachanged: me.onStoreDataChanged,
+                scope: me
+            }
+        });
+
+        if (me.node) {
+            me.setRootNode(me.node);
+        }
+        me.animQueue = {};
+        me.animWraps = {};
+        me.addEvents(
+            
+            'afteritemexpand',
+            
+            'afteritemcollapse'
+        );
+        me.callParent(arguments);
+        me.on({
+            element: 'el',
+            scope: me,
+            delegate: me.expanderSelector,
+            mouseover: me.onExpanderMouseOver,
+            mouseout: me.onExpanderMouseOut
+        });
+        me.on({
+            element: 'el',
+            scope: me,
+            delegate: me.checkboxSelector,
+            click: me.onCheckboxChange
+        });
+    },
+    
+    getMaskStore: function(){
+        return this.panel.getStore();    
+    },
+
+    afterComponentLayout: function(){
+        this.callParent(arguments);
+        var stretcher = this.stretcher;
+        if (stretcher) {
+            stretcher.setWidth((this.getWidth() - Ext.getScrollbarSize().width));
+        }
+    },
+
+    processUIEvent: function(e) {
+        
+        
+        
+        if (e.getTarget('.' + this.nodeAnimWrapCls, this.el)) {
+            return false;
+        }
+        return this.callParent(arguments);
+    },
+
+    onClear: function(){
+        this.store.removeAll();    
+    },
+
+    setRootNode: function(node) {
+        var me = this;        
+        me.store.setNode(node);
+        me.node = node;
+    },
+
+    onCheckboxChange: function(e, t) {
+        var me = this,
+            item = e.getTarget(me.getItemSelector(), me.getTargetEl());
+
+        if (item) {
+            me.onCheckChange(me.getRecord(item));
+        }
+    },
+
+    onCheckChange: function(record){
+        var checked = record.get('checked');
+        if (Ext.isBoolean(checked)) {
+            checked = !checked;
+            record.set('checked', checked);
+            this.fireEvent('checkchange', record, checked);
+        }
+    },
+
+    getChecked: function() {
+        var checked = [];
+        this.node.cascadeBy(function(rec){
+            if (rec.get('checked')) {
+                checked.push(rec);
+            }
+        });
+        return checked;
+    },
+
+    isItemChecked: function(rec){
+        return rec.get('checked');
+    },
+
+    
+    createAnimWrap: function(record, index) {
+        var thHtml = '',
+            headerCt = this.panel.headerCt,
+            headers = headerCt.getGridColumns(),
+            i = 0, len = headers.length, item,
+            node = this.getNode(record),
+            tmpEl, nodeEl;
+
+        for (; i < len; i++) {
+            item = headers[i];
+            thHtml += '<th style="width: ' + (item.hidden ? 0 : item.getDesiredWidth()) + 'px; height: 0px;"></th>';
+        }
+
+        nodeEl = Ext.get(node);        
+        tmpEl = nodeEl.insertSibling({
+            tag: 'tr',
+            html: [
+                '<td colspan="' + headerCt.getColumnCount() + '">',
+                    '<div class="' + this.nodeAnimWrapCls + '">',
+                        '<table class="' + Ext.baseCSSPrefix + 'grid-table" style="width: ' + headerCt.getFullWidth() + 'px;"><tbody>',
+                            thHtml,
+                        '</tbody></table>',
+                    '</div>',
+                '</td>'
+            ].join('')
+        }, 'after');
+
+        return {
+            record: record,
+            node: node,
+            el: tmpEl,
+            expanding: false,
+            collapsing: false,
+            animating: false,
+            animateEl: tmpEl.down('div'),
+            targetEl: tmpEl.down('tbody')
+        };
+    },
+
+    
+    getAnimWrap: function(parent, bubble) {
+        if (!this.animate) {
+            return null;
+        }
+
+        var wraps = this.animWraps,
+            wrap = wraps[parent.internalId];
+
+        if (bubble !== false) {
+            while (!wrap && parent) {
+                parent = parent.parentNode;
+                if (parent) {
+                    wrap = wraps[parent.internalId];
+                }
+            }
+        }
+        return wrap;
+    },
+
+    doAdd: function(nodes, records, index) {
+        
+        
+        var me = this,
+            record = records[0],
+            parent = record.parentNode,
+            a = me.all.elements,
+            relativeIndex = 0,
+            animWrap = me.getAnimWrap(parent),
+            targetEl, children, len;
+
+        if (!animWrap || !animWrap.expanding) {
+            return me.callParent(arguments);
+        }
+
+        
+        parent = animWrap.record;
+
+        
+        targetEl = animWrap.targetEl;
+        children = targetEl.dom.childNodes;
+
+        
+        len = children.length - 1;
+
+        
+        relativeIndex = index - me.indexOf(parent) - 1;
+
+        
+        
+        if (!len || relativeIndex >= len) {
+            targetEl.appendChild(nodes);
+        }
+        
+        
+        else {
+            
+            Ext.fly(children[relativeIndex + 1]).insertSibling(nodes, 'before', true);
+        }
+
+        
+        Ext.Array.insert(a, index, nodes);
+
+        
+        
+        if (animWrap.isAnimating) {
+            me.onExpand(parent);
+        }
+    },
+
+    beginBulkUpdate: function(){
+        this.bulkUpdate = true;  
+    },
+
+    endBulkUpdate: function(){
+        this.bulkUpdate = false;
+    },
+
+    onRemove : function(ds, record, index) {
+        var me = this,
+            bulk = me.bulkUpdate;
+            
+        if (me.viewReady) {
+            me.doRemove(record, index);
+            if (!bulk) {
+                me.updateIndexes(index);
+            }
+            if (me.store.getCount() === 0){
+                me.refresh();
+            }
+            if (!bulk) {
+                me.fireEvent('itemremove', record, index);
+            }
+        }
+    },
+
+    doRemove: function(record, index) {
+        
+        
+        var me = this,
+            all = me.all,
+            animWrap = me.getAnimWrap(record),
+            item = all.item(index),
+            node = item ? item.dom : null;
+
+        if (!node || !animWrap || !animWrap.collapsing) {
+            return me.callParent(arguments);
+        }
+
+        animWrap.targetEl.appendChild(node);
+        all.removeElement(index);
+    },
+
+    onBeforeExpand: function(parent, records, index) {
+        var me = this,
+            animWrap;
+
+        if (!me.rendered || !me.animate) {
+            return;
+        }
+
+        if (me.getNode(parent)) {
+            animWrap = me.getAnimWrap(parent, false);
+            if (!animWrap) {
+                animWrap = me.animWraps[parent.internalId] = me.createAnimWrap(parent);
+                animWrap.animateEl.setHeight(0);
+            }
+            else if (animWrap.collapsing) {
+                
+                
+                animWrap.targetEl.select(me.itemSelector).remove();
+            } 
+            animWrap.expanding = true;
+            animWrap.collapsing = false;
+        }
+    },
+
+    onExpand: function(parent) {
+        var me = this,
+            queue = me.animQueue,
+            id = parent.getId(),
+            node = me.getNode(parent),
+            index = node ? me.indexOf(node) : -1,
+            animWrap,
+            animateEl, 
+            targetEl;        
+
+        if (me.singleExpand) {
+            me.ensureSingleExpand(parent);
+        }
+
+        
+        if (index === -1) {
+            return;
+        }
+
+        animWrap = me.getAnimWrap(parent, false);
+
+        if (!animWrap) {
+            me.isExpandingOrCollapsing = false;
+            me.fireEvent('afteritemexpand', parent, index, node);
+            return;
+        }
+
+        animateEl = animWrap.animateEl;
+        targetEl = animWrap.targetEl;
+
+        animateEl.stopAnimation();
+        
+        queue[id] = true;
+        animateEl.slideIn('t', {
+            duration: me.expandDuration,
+            listeners: {
+                scope: me,
+                lastframe: function() {
+                    
+                    animWrap.el.insertSibling(targetEl.query(me.itemSelector), 'before');
+                    animWrap.el.remove();
+                    me.refreshSize();
+                    delete me.animWraps[animWrap.record.internalId];
+                    delete queue[id];
+                }
+            },
+            callback: function() {
+                me.isExpandingOrCollapsing = false;
+                me.fireEvent('afteritemexpand', parent, index, node);
+            }
+        });
+
+        animWrap.isAnimating = true;
+    },
+
+    onBeforeCollapse: function(parent, records, index) {
+        var me = this,
+            animWrap;
+
+        if (!me.rendered || !me.animate) {
+            return;
+        }
+
+        if (me.getNode(parent)) {
+            animWrap = me.getAnimWrap(parent);
+            if (!animWrap) {
+                animWrap = me.animWraps[parent.internalId] = me.createAnimWrap(parent, index);
+            }
+            else if (animWrap.expanding) {
+                
+                
+                animWrap.targetEl.select(this.itemSelector).remove();
+            }
+            animWrap.expanding = false;
+            animWrap.collapsing = true;
+        }
+    },
+
+    onCollapse: function(parent) {
+        var me = this,
+            queue = me.animQueue,
+            id = parent.getId(),
+            node = me.getNode(parent),
+            index = node ? me.indexOf(node) : -1,
+            animWrap = me.getAnimWrap(parent),
+            animateEl, targetEl;
+
+        
+        if (index === -1) {
+            return;
+        }
+
+        if (!animWrap) {
+            me.isExpandingOrCollapsing = false;
+            me.fireEvent('afteritemcollapse', parent, index, node);
+            return;
+        }
+
+        animateEl = animWrap.animateEl;
+        targetEl = animWrap.targetEl;
+
+        queue[id] = true;
+
+        
+        animateEl.stopAnimation();
+        animateEl.slideOut('t', {
+            duration: me.collapseDuration,
+            listeners: {
+                scope: me,
+                lastframe: function() {
+                    animWrap.el.remove();
+                    me.refreshSize();
+                    delete me.animWraps[animWrap.record.internalId];
+                    delete queue[id];
+                }             
+            },
+            callback: function() {
+                me.isExpandingOrCollapsing = false;
+                me.fireEvent('afteritemcollapse', parent, index, node);
+            }
+        });
+        animWrap.isAnimating = true;
+    },
+
+    
+    isAnimating: function(node) {
+        return !!this.animQueue[node.getId()];    
+    },
+
+    collectData: function(records) {
+        var data = this.callParent(arguments),
+            rows = data.rows,
+            len = rows.length,
+            i = 0,
+            row, record;
+
+        for (; i < len; i++) {
+            row = rows[i];
+            record = records[i];
+            if (record.get('qtip')) {
+                row.rowAttr = 'data-qtip="' + record.get('qtip') + '"';
+                if (record.get('qtitle')) {
+                    row.rowAttr += ' ' + 'data-qtitle="' + record.get('qtitle') + '"';
+                }
+            }
+            if (record.isExpanded()) {
+                row.rowCls = (row.rowCls || '') + ' ' + this.expandedCls;
+            }
+            if (record.isLeaf()) {
+                row.rowCls = (row.rowCls || '') + ' ' + this.leafCls;
+            }
+            if (record.isLoading()) {
+                row.rowCls = (row.rowCls || '') + ' ' + this.loadingCls;
+            }
+        }
+
+        return data;
+    },
+
+    
+    expand: function(record, deep, callback, scope) {
+        return record.expand(deep, callback, scope);
+    },
+
+    
+    collapse: function(record, deep, callback, scope) {
+        return record.collapse(deep, callback, scope);
+    },
+
+    
+    toggle: function(record, deep, callback, scope) {
+        var me = this,
+            doAnimate = !!this.animate;
+
+        
+        if (!doAnimate || !this.isExpandingOrCollapsing) {
+            if (!record.isLeaf()) {
+                this.isExpandingOrCollapsing = doAnimate;
+            }
+            if (record.isExpanded()) {
+                me.collapse(record, deep, callback, scope);
+            } else {
+                me.expand(record, deep, callback, scope);
+            }
+        }
+    },
+
+    onItemDblClick: function(record, item, index) {
+        var me = this,
+            editingPlugin = me.editingPlugin;
+            
+        me.callParent(arguments);
+        if (me.toggleOnDblClick && record.isExpandable() && !(editingPlugin && editingPlugin.clicksToEdit === 2)) {
+            me.toggle(record);
+        }
+    },
+
+    onBeforeItemMouseDown: function(record, item, index, e) {
+        if (e.getTarget(this.expanderSelector, item)) {
+            return false;
+        }
+        return this.callParent(arguments);
+    },
+
+    onItemClick: function(record, item, index, e) {
+        if (e.getTarget(this.expanderSelector, item) && record.isExpandable()) {
+            this.toggle(record, e.ctrlKey);
+            return false;
+        }
+        return this.callParent(arguments);
+    },
+
+    onExpanderMouseOver: function(e, t) {
+        e.getTarget(this.cellSelector, 10, true).addCls(this.expanderIconOverCls);
+    },
+
+    onExpanderMouseOut: function(e, t) {
+        e.getTarget(this.cellSelector, 10, true).removeCls(this.expanderIconOverCls);
+    },
+
+    
+    getTreeStore: function() {
+        return this.panel.store;
+    },    
+
+    ensureSingleExpand: function(node) {
+        var parent = node.parentNode;
+        if (parent) {
+            parent.eachChild(function(child) {
+                if (child !== node && child.isExpanded()) {
+                    child.collapse();
+                }
+            });
+        }
+    },
+
+    shouldUpdateCell: function(column, changedFieldNames){
+        if (changedFieldNames) {
+            var i = 0,
+                len = changedFieldNames.length;
+                
+            for (; i < len; ++i) {
+                if (Ext.Array.contains(this.uiFields, changedFieldNames[i])) {
+                    return true;
+                }
+            }
+        }
+        return this.callParent(arguments);
+    },
+
+    
+    onStoreWrite: function(store, operation) {
+        var treeStore = this.panel.store;
+        treeStore.fireEvent('write', treeStore, operation);
+    },
+
+    
+    onStoreDataChanged: function(store, operation) {
+        var treeStore = this.panel.store;
+        treeStore.fireEvent('datachanged', treeStore);
+    }
+});
+
+
+Ext.define('Ext.tree.Panel', {
+    extend: 'Ext.panel.Table',
+    alias: 'widget.treepanel',
+    alternateClassName: ['Ext.tree.TreePanel', 'Ext.TreePanel'],
+    requires: ['Ext.tree.View', 'Ext.selection.TreeModel', 'Ext.tree.Column', 'Ext.data.TreeStore'],
+    viewType: 'treeview',
+    selType: 'treemodel',
+
+    treeCls: Ext.baseCSSPrefix + 'tree-panel',
+
+    deferRowRender: false,
+
+    
+    rowLines: false,
+
+    
+    lines: true,
+
+    
+    useArrows: false,
+
+    
+    singleExpand: false,
+
+    ddConfig: {
+        enableDrag: true,
+        enableDrop: true
+    },
+
+    
+
+    
+    rootVisible: true,
+
+    
+    displayField: 'text',
+
+    
+    root: null,
+
+    
+    
+    normalCfgCopy: ['displayField', 'root', 'singleExpand', 'useArrows', 'lines', 'rootVisible', 'scroll'],
+    lockedCfgCopy: ['displayField', 'root', 'singleExpand', 'useArrows', 'lines', 'rootVisible'],
+    
+    isTree: true,
+
+    
+
+    
+     
+    
+
+    constructor: function(config) {
+        config = config || {};
+        if (config.animate === undefined) {
+            config.animate = Ext.isDefined(this.animate) ? this.animate : Ext.enableFx;
+        }
+        this.enableAnimations = config.animate;
+        delete config.animate;
+
+        this.callParent([config]);
+    },
+
+    initComponent: function() {
+        var me = this,
+            cls = [me.treeCls],
+            view;
+
+        if (me.useArrows) {
+            cls.push(Ext.baseCSSPrefix + 'tree-arrows');
+            me.lines = false;
+        }
+
+        if (me.lines) {
+            cls.push(Ext.baseCSSPrefix + 'tree-lines');
+        } else if (!me.useArrows) {
+            cls.push(Ext.baseCSSPrefix + 'tree-no-lines');
+        }
+
+        if (Ext.isString(me.store)) {
+            me.store = Ext.StoreMgr.lookup(me.store);
+        } else if (!me.store || Ext.isObject(me.store) && !me.store.isStore) {
+            me.store = new Ext.data.TreeStore(Ext.apply({}, me.store || {}, {
+                root: me.root,
+                fields: me.fields,
+                model: me.model,
+                folderSort: me.folderSort
+            }));
+        } else if (me.root) {
+            me.store = Ext.data.StoreManager.lookup(me.store);
+            me.store.setRootNode(me.root);
+            if (me.folderSort !== undefined) {
+                me.store.folderSort = me.folderSort;
+                me.store.sort();
+            }
+        }
+
+        
+        
+        
+        
+
+        me.viewConfig = Ext.apply({}, me.viewConfig);
+        me.viewConfig = Ext.applyIf(me.viewConfig, {
+            rootVisible: me.rootVisible,
+            animate: me.enableAnimations,
+            singleExpand: me.singleExpand,
+            node: me.store.getRootNode(),
+            hideHeaders: me.hideHeaders
+        });
+
+        me.mon(me.store, {
+            scope: me,
+            rootchange: me.onRootChange,
+            clear: me.onClear
+        });
+
+        me.relayEvents(me.store, [
+            
+            'beforeload',
+
+            
+            'load'
+        ]);
+
+        me.mon(me.store, {
+            
+            append: me.createRelayer('itemappend'),
+
+            
+            remove: me.createRelayer('itemremove'),
+
+            
+            move: me.createRelayer('itemmove', [0, 4]),
+
+            
+            insert: me.createRelayer('iteminsert'),
+
+            
+            beforeappend: me.createRelayer('beforeitemappend'),
+
+            
+            beforeremove: me.createRelayer('beforeitemremove'),
+
+            
+            beforemove: me.createRelayer('beforeitemmove'),
+
+            
+            beforeinsert: me.createRelayer('beforeiteminsert'),
+
+            
+            expand: me.createRelayer('itemexpand', [0, 1]),
+
+            
+            collapse: me.createRelayer('itemcollapse', [0, 1]),
+
+            
+            beforeexpand: me.createRelayer('beforeitemexpand', [0, 1]),
+
+            
+            beforecollapse: me.createRelayer('beforeitemcollapse', [0, 1])
+        });
+
+        
+        if (!me.columns) {
+            if (me.initialConfig.hideHeaders === undefined) {
+                me.hideHeaders = true;
+            }
+            me.addCls(Ext.baseCSSPrefix + 'autowidth-table');
+            me.columns = [{
+                xtype    : 'treecolumn',
+                text     : 'Name',
+                width    : Ext.isIE6 ? null : 10000,
+                dataIndex: me.displayField         
+            }];
+        }
+
+        if (me.cls) {
+            cls.push(me.cls);
+        }
+        me.cls = cls.join(' ');
+        me.callParent();
+        
+        view = me.getView();
+
+        me.relayEvents(view, [
+            
+            'checkchange',
+            
+            'afteritemexpand',
+            
+            'afteritemcollapse'
+        ]);
+
+        
+        if (!view.rootVisible && !me.getRootNode()) {
+            me.setRootNode({
+                expanded: true
+            });
+        }
+    },
+    
+    onClear: function(){
+        this.view.onClear();
+    },
+
+    
+    setRootNode: function() {
+        return this.store.setRootNode.apply(this.store, arguments);
+    },
+
+    
+    getRootNode: function() {
+        return this.store.getRootNode();
+    },
+
+    onRootChange: function(root) {
+        this.view.setRootNode(root);
+    },
+
+    
+    getChecked: function() {
+        return this.getView().getChecked();
+    },
+
+    isItemChecked: function(rec) {
+        return rec.get('checked');
+    },
+    
+    
+    expandNode: function(record, deep, callback, scope) {
+        return this.getView().expand(record, deep, callback, scope || this);
+    },
+
+    
+    collapseNode: function(record, deep, callback, scope) {
+        return this.getView().collapse(record, deep, callback, scope || this);
+    },
+
+    
+    expandAll : function(callback, scope) {
+        var me = this,
+            root = me.getRootNode(),
+            animate = me.enableAnimations,
+            view = me.getView();
+        if (root) {
+            if (!animate) {
+                view.beginBulkUpdate();
+            }
+            root.expand(true, callback, scope || me);
+            if (!animate) {
+                view.endBulkUpdate();
+            }
+        }
+    },
+
+    
+    collapseAll : function(callback, scope) {
+        var me = this,
+            root = me.getRootNode(),
+            animate = me.enableAnimations,
+            view = me.getView();
+
+        if (root) {
+            if (!animate) {
+                view.beginBulkUpdate();
+            }
+            scope = scope || me;
+            if (view.rootVisible) {
+                root.collapse(true, callback, scope);
+            } else {
+                root.collapseChildren(true, callback, scope);
+            }
+            if (!animate) {
+                view.endBulkUpdate();
+            }
+        }
+    },
+
+    
+    expandPath: function(path, field, separator, callback, scope) {
+        var me = this,
+            current = me.getRootNode(),
+            index = 1,
+            view = me.getView(),
+            keys,
+            expander;
+
+        field = field || me.getRootNode().idProperty;
+        separator = separator || '/';
+
+        if (Ext.isEmpty(path)) {
+            Ext.callback(callback, scope || me, [false, null]);
+            return;
+        }
+
+        keys = path.split(separator);
+        if (current.get(field) != keys[1]) {
+            
+            Ext.callback(callback, scope || me, [false, current]);
+            return;
+        }
+
+        expander = function(){
+            if (++index === keys.length) {
+                Ext.callback(callback, scope || me, [true, current]);
+                return;
+            }
+            var node = current.findChild(field, keys[index]);
+            if (!node) {
+                Ext.callback(callback, scope || me, [false, current]);
+                return;
+            }
+            current = node;
+            current.expand(false, expander);
+        };
+        current.expand(false, expander);
+    },
+
+    
+    selectPath: function(path, field, separator, callback, scope) {
+        var me = this,
+            root,
+            keys,
+            last;
+
+        field = field || me.getRootNode().idProperty;
+        separator = separator || '/';
+
+        keys = path.split(separator);
+        last = keys.pop();
+        if (keys.length > 1) {
+            me.expandPath(keys.join(separator), field, separator, function(success, node){
+                var lastNode = node;
+                if (success && node) {
+                    node = node.findChild(field, last);
+                    if (node) {
+                        me.getSelectionModel().select(node);
+                        Ext.callback(callback, scope || me, [true, node]);
+                        return;
+                    }
+                }
+                Ext.callback(callback, scope || me, [false, lastNode]);
+            }, me);
+        } else {
+            root = me.getRootNode();
+            if (root.getId() === last) {
+                me.getSelectionModel().select(root);
+                Ext.callback(callback, scope || me, [true, root]);
+            } else {
+                Ext.callback(callback, scope || me, [false, null]);
+            }
+        }
+    }
+});
+
+
+Ext.define('Ext.view.DragZone', {
+    extend: 'Ext.dd.DragZone',
+    containerScroll: false,
+
+    constructor: function(config) {
+        var me = this,
+            view,
+            ownerCt,
+            el;
+
+        Ext.apply(me, config);
+
+        
+        
+        
+        
+        
+        if (!me.ddGroup) {
+            me.ddGroup = 'view-dd-zone-' + me.view.id;
+        }
+
+        
+        
+        
+        
+        
+        
+        
+        view = me.view;
+        ownerCt = view.ownerCt;
+        
+        
+        if (ownerCt) {
+            el = ownerCt.getTargetEl().dom;
+        } else {
+            el = view.el.dom.parentNode;
+        }
+        me.callParent([el]);
+
+        me.ddel = Ext.get(document.createElement('div'));
+        me.ddel.addCls(Ext.baseCSSPrefix + 'grid-dd-wrap');
+    },
+
+    init: function(id, sGroup, config) {
+        this.initTarget(id, sGroup, config);
+        this.view.mon(this.view, {
+            itemmousedown: this.onItemMouseDown,
+            scope: this
+        });
+    },
+
+    onValidDrop: function(target, e, id) {
+        this.callParent();
+        
+        target.el.focus();
+    },
+    
+    onItemMouseDown: function(view, record, item, index, e) {
+        if (!this.isPreventDrag(e, record, item, index)) {
+            
+            
+            
+            this.view.focus();
+            this.handleMouseDown(e);
+
+            
+            
+            if (view.getSelectionModel().selectionMode == 'MULTI' && !e.ctrlKey && view.getSelectionModel().isSelected(record)) {
+                return false;
+            }
+        }
+    },
+
+    
+    isPreventDrag: function(e) {
+        return false;
+    },
+
+    getDragData: function(e) {
+        var view = this.view,
+            item = e.getTarget(view.getItemSelector());
+
+        if (item) {
+            return {
+                copy: view.copy || (view.allowCopy && e.ctrlKey),
+                event: new Ext.EventObjectImpl(e),
+                view: view,
+                ddel: this.ddel,
+                item: item,
+                records: view.getSelectionModel().getSelection(),
+                fromPosition: Ext.fly(item).getXY()
+            };
+        }
+    },
+
+    onInitDrag: function(x, y) {
+        var me = this,
+            data = me.dragData,
+            view = data.view,
+            selectionModel = view.getSelectionModel(),
+            record = view.getRecord(data.item),
+            e = data.event;
+
+        
+        
+        if (!selectionModel.isSelected(record)) {
+            selectionModel.select(record, true);
+        }
+        data.records = selectionModel.getSelection();
+
+        me.ddel.update(me.getDragText());
+        me.proxy.update(me.ddel.dom);
+        me.onStartDrag(x, y);
+        return true;
+    },
+
+    getDragText: function() {
+        var count = this.dragData.records.length;
+        return Ext.String.format(this.dragText, count, count == 1 ? '' : 's');
+    },
+
+    getRepairXY : function(e, data){
+        return data ? data.fromPosition : false;
+    }
+});
+
+
+Ext.define('Ext.tree.ViewDragZone', {
+    extend: 'Ext.view.DragZone',
+
+    isPreventDrag: function(e, record) {
+        return (record.get('allowDrag') === false) || !!e.getTarget(this.view.expanderSelector);
+    },
+    
+    afterRepair: function() {
+        var me = this,
+            view = me.view,
+            selectedRowCls = view.selectedItemCls,
+            records = me.dragData.records,
+            r,
+            rLen    = records.length,
+            fly = Ext.fly,
+            item;
+        
+        if (Ext.enableFx && me.repairHighlight) {
+            
+            for (r = 0; r < rLen; r++) {
+                
+                
+                item = view.getNode(records[r]);
+
+                
+                
+                fly(item.firstChild).highlight(me.repairHighlightColor, {
+                    listeners: {
+                        beforeanimate: function() {
+                            if (view.isSelected(item)) {
+                                fly(item).removeCls(selectedRowCls);
+                            }
+                        },
+                        afteranimate: function() {
+                            if (view.isSelected(item)) {
+                                fly(item).addCls(selectedRowCls);
+                            }
+                        }
+                    }
+                });
+            }
+
+        }
+        me.dragging = false;
+    }
+});
+
+
+Ext.define('Ext.tree.ViewDropZone', {
+    extend: 'Ext.view.DropZone',
+
+    
+    allowParentInserts: false,
+ 
+    
+    allowContainerDrops: false,
+
+    
+    appendOnly: false,
+
+    
+    expandDelay : 500,
+
+    indicatorCls: Ext.baseCSSPrefix + 'tree-ddindicator',
+
+    
+    expandNode : function(node) {
+        var view = this.view;
+        if (!node.isLeaf() && !node.isExpanded()) {
+            view.expand(node);
+            this.expandProcId = false;
+        }
+    },
+
+    
+    queueExpand : function(node) {
+        this.expandProcId = Ext.Function.defer(this.expandNode, this.expandDelay, this, [node]);
+    },
+
+    
+    cancelExpand : function() {
+        if (this.expandProcId) {
+            clearTimeout(this.expandProcId);
+            this.expandProcId = false;
+        }
+    },
+
+    getPosition: function(e, node) {
+        var view = this.view,
+            record = view.getRecord(node),
+            y = e.getPageY(),
+            noAppend = record.isLeaf(),
+            noBelow = false,
+            region = Ext.fly(node).getRegion(),
+            fragment;
+
+        
+        if (record.isRoot()) {
+            return 'append';
+        }
+
+        
+        if (this.appendOnly) {
+            return noAppend ? false : 'append';
+        }
+
+        if (!this.allowParentInsert) {
+            noBelow = record.hasChildNodes() && record.isExpanded();
+        }
+
+        fragment = (region.bottom - region.top) / (noAppend ? 2 : 3);
+        if (y >= region.top && y < (region.top + fragment)) {
+            return 'before';
+        }
+        else if (!noBelow && (noAppend || (y >= (region.bottom - fragment) && y <= region.bottom))) {
+            return 'after';
+        }
+        else {
+            return 'append';
+        }
+    },
+
+    isValidDropPoint : function(node, position, dragZone, e, data) {
+        if (!node || !data.item) {
+            return false;
+        }
+
+        var view = this.view,
+            targetNode = view.getRecord(node),
+            draggedRecords = data.records,
+            dataLength = draggedRecords.length,
+            ln = draggedRecords.length,
+            i, record;
+
+        
+        if (!(targetNode && position && dataLength)) {
+            return false;
+        }
+
+        
+        for (i = 0; i < ln; i++) {
+            record = draggedRecords[i];
+            if (record.isNode && record.contains(targetNode)) {
+                return false;
+            }
+        }
+        
+        
+        if (position === 'append' && targetNode.get('allowDrop') === false) {
+            return false;
+        }
+        else if (position != 'append' && targetNode.parentNode.get('allowDrop') === false) {
+            return false;
+        }
+
+        
+        if (Ext.Array.contains(draggedRecords, targetNode)) {
+             return false;
+        }
+
+        
+        
+        return true;
+    },
+
+    onNodeOver : function(node, dragZone, e, data) {
+        var position = this.getPosition(e, node),
+            returnCls = this.dropNotAllowed,
+            view = this.view,
+            targetNode = view.getRecord(node),
+            indicator = this.getIndicator(),
+            indicatorX = 0,
+            indicatorY = 0;
+
+        
+        this.cancelExpand();
+        if (position == 'append' && !this.expandProcId && !Ext.Array.contains(data.records, targetNode) && !targetNode.isLeaf() && !targetNode.isExpanded()) {
+            this.queueExpand(targetNode);
+        }
+            
+            
+        if (this.isValidDropPoint(node, position, dragZone, e, data)) {
+            this.valid = true;
+            this.currentPosition = position;
+            this.overRecord = targetNode;
+
+            indicator.setWidth(Ext.fly(node).getWidth());
+            indicatorY = Ext.fly(node).getY() - Ext.fly(view.el).getY() - 1;
+
+            
+            if (position == 'before') {
+                returnCls = targetNode.isFirst() ? Ext.baseCSSPrefix + 'tree-drop-ok-above' : Ext.baseCSSPrefix + 'tree-drop-ok-between';
+                indicator.showAt(0, indicatorY);
+                dragZone.proxy.show();
+            } else if (position == 'after') {
+                returnCls = targetNode.isLast() ? Ext.baseCSSPrefix + 'tree-drop-ok-below' : Ext.baseCSSPrefix + 'tree-drop-ok-between';
+                indicatorY += Ext.fly(node).getHeight();
+                indicator.showAt(0, indicatorY);
+                dragZone.proxy.show();
+            } else {
+                returnCls = Ext.baseCSSPrefix + 'tree-drop-ok-append';
+                
+                indicator.hide();
+            }
+        } else {
+            this.valid = false;
+        }
+
+        this.currentCls = returnCls;
+        return returnCls;
+    },
+
+    onContainerOver : function(dd, e, data) {
+        return e.getTarget('.' + this.indicatorCls) ? this.currentCls : this.dropNotAllowed;
+    },
+    
+    notifyOut: function() {
+        this.callParent(arguments);
+        this.cancelExpand();
+    },
+
+    handleNodeDrop : function(data, targetNode, position) {
+        var me = this,
+            view = me.view,
+            parentNode = targetNode.parentNode,
+            store = view.getStore(),
+            recordDomNodes = [],
+            records, i, len,
+            insertionMethod, argList,
+            needTargetExpand,
+            transferData,
+            processDrop;
+
+        
+        if (data.copy) {
+            records = data.records;
+            data.records = [];
+            for (i = 0, len = records.length; i < len; i++) {
+                data.records.push(Ext.apply({}, records[i].data));
+            }
+        }
+
+        
+        me.cancelExpand();
+
+        
+        
+        
+        
+        if (position == 'before') {
+            insertionMethod = parentNode.insertBefore;
+            argList = [null, targetNode];
+            targetNode = parentNode;
+        }
+        else if (position == 'after') {
+            if (targetNode.nextSibling) {
+                insertionMethod = parentNode.insertBefore;
+                argList = [null, targetNode.nextSibling];
+            }
+            else {
+                insertionMethod = parentNode.appendChild;
+                argList = [null];
+            }
+            targetNode = parentNode;
+        }
+        else {
+            if (!targetNode.isExpanded()) {
+                needTargetExpand = true;
+            }
+            insertionMethod = targetNode.appendChild;
+            argList = [null];
+        }
+
+        
+        transferData = function() {
+            var node,
+                r, rLen, color, n;
+            for (i = 0, len = data.records.length; i < len; i++) {
+                argList[0] = data.records[i];
+                node = insertionMethod.apply(targetNode, argList);
+                
+                if (Ext.enableFx && me.dropHighlight) {
+                    recordDomNodes.push(view.getNode(node));
+                }
+            }
+            
+            
+            
+            if (Ext.enableFx && me.dropHighlight) {
+                
+                
+                rLen  = recordDomNodes.length;
+                color = me.dropHighlightColor;
+
+                for (r = 0; r < rLen; r++) {
+                    n = recordDomNodes[r];
+
+                    if (n) {
+                        Ext.fly(n.firstChild ? n.firstChild : n).highlight(color);
+                    }
+                }
+            }
+        };
+
+        
+        if (needTargetExpand) {
+            targetNode.expand(false, transferData);
+        }
+        
+        else {
+            transferData();
+        }
+    }
+});
+
+
+Ext.define('Ext.tree.plugin.TreeViewDragDrop', {
+    extend: 'Ext.AbstractPlugin',
+    alias: 'plugin.treeviewdragdrop',
+
+    uses: [
+        'Ext.tree.ViewDragZone',
+        'Ext.tree.ViewDropZone'
+    ],
+
+    
+
+    
+
+    
+    
+    dragText : '{0} selected node{1}',
+    
+
+    
+    allowParentInserts: false,
+
+    
+    allowContainerDrops: false,
+
+    
+    appendOnly: false,
+
+    
+    ddGroup : "TreeDD",
+
+    
+
+    
+
+    
+    expandDelay : 1000,
+
+    
+    enableDrop: true,
+
+    
+    enableDrag: true,
+
+    
+    nodeHighlightColor: 'c3daf9',
+
+    
+    nodeHighlightOnDrop: Ext.enableFx,
+
+    
+    nodeHighlightOnRepair: Ext.enableFx,
+
+    init : function(view) {
+        view.on('render', this.onViewRender, this, {single: true});
+    },
+
+    
+    destroy: function() {
+        Ext.destroy(this.dragZone, this.dropZone);
+    },
+
+    onViewRender : function(view) {
+        var me = this;
+
+        if (me.enableDrag) {
+            me.dragZone = new Ext.tree.ViewDragZone({
+                view: view,
+                ddGroup: me.dragGroup || me.ddGroup,
+                dragText: me.dragText,
+                repairHighlightColor: me.nodeHighlightColor,
+                repairHighlight: me.nodeHighlightOnRepair
+            });
+        }
+
+        if (me.enableDrop) {
+            me.dropZone = new Ext.tree.ViewDropZone({
+                view: view,
+                ddGroup: me.dropGroup || me.ddGroup,
+                allowContainerDrops: me.allowContainerDrops,
+                appendOnly: me.appendOnly,
+                allowParentInserts: me.allowParentInserts,
+                expandDelay: me.expandDelay,
+                dropHighlightColor: me.nodeHighlightColor,
+                dropHighlight: me.nodeHighlightOnDrop
+            });
+        }
+    }
+});
+
+
+Ext.define('Ext.util.CSS', (function() {
+    var rules = null,
+        doc = document,
+        camelRe = /(-[a-z])/gi,
+        camelFn = function(m, a){ return a.charAt(1).toUpperCase(); };
+
+    return {
+
+        singleton: true,
+
+        constructor: function() {
+            this.rules = {};
+            this.initialized = false;
+        },
+
+        
+        createStyleSheet : function(cssText, id) {
+            var ss,
+                head = doc.getElementsByTagName("head")[0],
+                styleEl = doc.createElement("style");
+
+            styleEl.setAttribute("type", "text/css");
+            if (id) {
+               styleEl.setAttribute("id", id);
+            }
+
+            if (Ext.isIE) {
+               head.appendChild(styleEl);
+               ss = styleEl.styleSheet;
+               ss.cssText = cssText;
+            } else {
+                try{
+                    styleEl.appendChild(doc.createTextNode(cssText));
+                } catch(e) {
+                   styleEl.cssText = cssText;
+                }
+                head.appendChild(styleEl);
+                ss = styleEl.styleSheet ? styleEl.styleSheet : (styleEl.sheet || doc.styleSheets[doc.styleSheets.length-1]);
+            }
+            this.cacheStyleSheet(ss);
+            return ss;
+        },
+
+        
+        removeStyleSheet : function(id) {
+            var existing = document.getElementById(id);
+            if (existing) {
+                existing.parentNode.removeChild(existing);
+            }
+        },
+
+        
+        swapStyleSheet : function(id, url) {
+            var doc = document,
+                ss;
+            this.removeStyleSheet(id);
+            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,
+                    selectorText,
+                    i = ssRules.length - 1,
+                    j,
+                    selectors;
+
+                for (; i >= 0; --i) {
+                    selectorText = ssRules[i].selectorText;
+                    if (selectorText) {
+
+                        
+                        selectorText = selectorText.split(',');
+                        selectors = selectorText.length;
+                        for (j = 0; j < selectors; j++) {
+                            rules[Ext.String.trim(selectorText[j]).toLowerCase()] = ssRules[i];
+                        }
+                    }
+                }
+            } catch(e) {}
+        },
+
+        
+        getRules : function(refreshCache) {
+            if (rules === null || refreshCache) {
+                rules = {};
+                var ds = doc.styleSheets,
+                    i = 0,
+                    len = ds.length;
+
+                for (; i < len; i++) {
+                    try {
+                        if (!ds[i].disabled) {
+                            this.cacheStyleSheet(ds[i]);
+                        }
+                    } catch(e) {}
+                }
+            }
+            return rules;
+        },
+
+        
+        getRule: function(selector, refreshCache) {
+            var rs = this.getRules(refreshCache),
+                i;
+            if (!Ext.isArray(selector)) {
+                return rs[selector.toLowerCase()];
+            }
+            for (i = 0; i < selector.length; i++) {
+                if (rs[selector[i]]) {
+                    return rs[selector[i].toLowerCase()];
+                }
+            }
+            return null;
+        },
+
+        
+        updateRule : function(selector, property, value){
+            var rule, i;
+            if (!Ext.isArray(selector)) {
+                rule = this.getRule(selector);
+                if (rule) {
+                    rule.style[property.replace(camelRe, camelFn)] = value;
+                    return true;
+                }
+            } else {
+                for (i = 0; i < selector.length; i++) {
+                    if (this.updateRule(selector[i], property, value)) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+    };
+}()));
+
+
+Ext.define('Ext.util.Cookies', {
+    singleton: true,
+    
+    
+    set : function(name, value){
+        var argv = arguments,
+            argc = arguments.length,
+            expires = (argc > 2) ? argv[2] : null,
+            path = (argc > 3) ? argv[3] : '/',
+            domain = (argc > 4) ? argv[4] : null,
+            secure = (argc > 5) ? argv[5] : false;
+            
+        document.cookie = name + "=" + escape(value) + ((expires === null) ? "" : ("; expires=" + expires.toGMTString())) + ((path === null) ? "" : ("; path=" + path)) + ((domain === null) ? "" : ("; domain=" + domain)) + ((secure === true) ? "; secure" : "");
+    },
+
+    
+    get : function(name){
+        var arg = name + "=",
+            alen = arg.length,
+            clen = document.cookie.length,
+            i = 0,
+            j = 0;
+            
+        while(i < clen){
+            j = i + alen;
+            if(document.cookie.substring(i, j) == arg){
+                return this.getCookieVal(j);
+            }
+            i = document.cookie.indexOf(" ", i) + 1;
+            if(i === 0){
+                break;
+            }
+        }
+        return null;
+    },
+
+    
+    clear : function(name, path){
+        if(this.get(name)){
+            path = path || '/';
+            document.cookie = name + '=' + '; expires=Thu, 01-Jan-70 00:00:01 GMT; path=' + path;
+        }
+    },
+    
+    
+    getCookieVal : function(offset){
+        var endstr = document.cookie.indexOf(";", offset);
+        if(endstr == -1){
+            endstr = document.cookie.length;
+        }
+        return unescape(document.cookie.substring(offset, endstr));
+    }
+});
+
+
+ 
+Ext.define('Ext.util.Grouper', {
+
+    
+
+    extend: 'Ext.util.Sorter',
+
+    
+   
+   isGrouper: true,
+
+    
+    getGroupString: function(instance) {
+        return instance.get(this.property);
+    }
+});
+
+
+Ext.define('Ext.util.History', {
+    singleton: true,
+    alternateClassName: 'Ext.History',
+    mixins: {
+        observable: 'Ext.util.Observable'
+    },
+
+    
+    useTopWindow: true,
+
+    
+    fieldId: Ext.baseCSSPrefix + 'history-field',
+    
+    iframeId: Ext.baseCSSPrefix + 'history-frame',
+
+    constructor: function() {
+        var me = this;
+        me.oldIEMode = Ext.isIE6 || Ext.isIE7 || !Ext.isStrict && Ext.isIE8;
+        me.iframe = null;
+        me.hiddenField = null;
+        me.ready = false;
+        me.currentToken = null;
+        me.mixins.observable.constructor.call(me);
+    },
+
+    getHash: function() {
+        var href = window.location.href,
+            i = href.indexOf("#");
+
+        return i >= 0 ? href.substr(i + 1) : null;
+    },
+
+    setHash: function (hash) {
+        var me = this,
+            win = me.useTopWindow ? window.top : window;
+        try {
+            win.location.hash = hash;
+        } catch (e) {
+            
+        }
+    },
+
+    doSave: function() {
+        this.hiddenField.value = this.currentToken;
+    },
+
+
+    handleStateChange: function(token) {
+        this.currentToken = token;
+        this.fireEvent('change', token);
+    },
+
+    updateIFrame: function(token) {
+        var html = '<html><body><div id="state">' +
+                    Ext.util.Format.htmlEncode(token) +
+                    '</div></body></html>',
+            doc;
+
+        try {
+            doc = this.iframe.contentWindow.document;
+            doc.open();
+            doc.write(html);
+            doc.close();
+            return true;
+        } catch (e) {
+            return false;
+        }
+    },
+
+    checkIFrame: function () {
+        var me = this,
+            contentWindow = me.iframe.contentWindow,
+            doc, elem, oldToken, oldHash;
+
+        if (!contentWindow || !contentWindow.document) {
+            Ext.Function.defer(this.checkIFrame, 10, this);
+            return;
+        }
+
+        doc = contentWindow.document;
+        elem = doc.getElementById("state");
+        oldToken = elem ? elem.innerText : null;
+        oldHash = me.getHash();
+
+        Ext.TaskManager.start({
+            run: function () {
+                var doc = contentWindow.document,
+                    elem = doc.getElementById("state"),
+                    newToken = elem ? elem.innerText : null,
+                    newHash = me.getHash();
+
+                if (newToken !== oldToken) {
+                    oldToken = newToken;
+                    me.handleStateChange(newToken);
+                    me.setHash(newToken);
+                    oldHash = newToken;
+                    me.doSave();
+                } else if (newHash !== oldHash) {
+                    oldHash = newHash;
+                    me.updateIFrame(newHash);
+                }
+            },
+            interval: 50,
+            scope: me
+        });
+        me.ready = true;
+        me.fireEvent('ready', me);
+    },
+
+    startUp: function () {
+        var me = this,
+            hash;
+
+        me.currentToken = me.hiddenField.value || this.getHash();
+
+        if (me.oldIEMode) {
+            me.checkIFrame();
+        } else {
+            hash = me.getHash();
+            Ext.TaskManager.start({
+                run: function () {
+                    var newHash = me.getHash();
+                    if (newHash !== hash) {
+                        hash = newHash;
+                        me.handleStateChange(hash);
+                        me.doSave();
+                    }
+                },
+                interval: 50,
+                scope: me
+            });
+            me.ready = true;
+            me.fireEvent('ready', me);
+        }
+
+    },
+
+    
+    init: function (onReady, scope) {
+        var me = this,
+            DomHelper = Ext.DomHelper;
+
+        if (me.ready) {
+            Ext.callback(onReady, scope, [me]);
+            return;
+        }
+
+        if (!Ext.isReady) {
+            Ext.onReady(function() {
+                me.init(onReady, scope);
+            });
+            return;
+        }
+
+        
+        me.hiddenField = Ext.getDom(me.fieldId);
+        if (!me.hiddenField) {
+            me.hiddenField = Ext.getBody().createChild({
+                id: Ext.id(),
+                tag: 'form',
+                cls: Ext.baseCSSPrefix + 'hide-display',
+                children: [{
+                    tag: 'input',
+                    type: 'hidden',
+                    id: me.fieldId
+                }]
+            }, false, true).firstChild;
+        }
+
+        if (me.oldIEMode) {
+            me.iframe = Ext.getDom(me.iframeId);
+            if (!me.iframe) {
+                me.iframe = DomHelper.append(me.hiddenField.parentNode, {
+                    tag: 'iframe',
+                    id: me.iframeId,
+                    src: Ext.SSL_SECURE_URL
+                });
+            }
+        }
+
+        me.addEvents(
+            
+            'ready',
+            
+            'change'
+        );
+
+        if (onReady) {
+            me.on('ready', onReady, scope, {single: true});
+        }
+        me.startUp();
+    },
+
+    
+    add: function (token, preventDup) {
+        var me = this;
+
+        if (preventDup !== false) {
+            if (me.getToken() === token) {
+                return true;
+            }
+        }
+
+        if (me.oldIEMode) {
+            return me.updateIFrame(token);
+        } else {
+            me.setHash(token);
+            return true;
+        }
+    },
+
+    
+    back: function() {
+        window.history.go(-1);
+    },
+
+    
+    forward: function(){
+        window.history.go(1);
+    },
+
+    
+    getToken: function() {
+        return this.ready ? this.currentToken : this.getHash();
+    }
+});
+
+
+Ext.define('Ext.util.Point', {
+
+    
+    extend: 'Ext.util.Region',
+
+    statics: {
+
+        
+        fromEvent: function(e) {
+            e = (e.changedTouches && e.changedTouches.length > 0) ? e.changedTouches[0] : e;
+            return new this(e.pageX, e.pageY);
+        }
+    },
+
+    
+
+    
+    constructor: function(x, y) {
+        this.callParent([y, x, y, x]);
+    },
+
+    
+    toString: function() {
+        return "Point[" + this.x + "," + this.y + "]";
+    },
+
+    
+    equals: function(p) {
+        return (this.x == p.x && this.y == p.y);
+    },
+
+    
+    isWithin: function(p, threshold) {
+        if (!Ext.isObject(threshold)) {
+            threshold = {
+                x: threshold,
+                y: threshold
+            };
+        }
+
+        return (this.x <= p.x + threshold.x && this.x >= p.x - threshold.x &&
+                this.y <= p.y + threshold.y && this.y >= p.y - threshold.y);
+    },
+
+    
+    roundedEquals: function(p) {
+        return (Math.round(this.x) == Math.round(p.x) && Math.round(this.y) == Math.round(p.y));
+    }
+}, function() {
+    
+    this.prototype.translate = Ext.util.Region.prototype.translateBy;
+});
+
+
+Ext.define('Ext.view.TableChunker', {
+    singleton: true,
+    requires: ['Ext.XTemplate'],
+    metaTableTpl: [
+        '{%if (this.openTableWrap)out.push(this.openTableWrap())%}',
+        '<table class="' + Ext.baseCSSPrefix + 'grid-table ' + Ext.baseCSSPrefix + 'grid-table-resizer" border="0" cellspacing="0" cellpadding="0" {[this.embedFullWidth(values)]}>',
+            '<tbody>',
+            '<tr class="' + Ext.baseCSSPrefix + 'grid-header-row">',
+            '<tpl for="columns">',
+                '<th class="' + Ext.baseCSSPrefix + 'grid-col-resizer-{id}" style="width: {width}px; height: 0px;"></th>',
+            '</tpl>',
+            '</tr>',
+            '{[this.openRows()]}',
+                '{row}',
+                '<tpl for="features">',
+                    '{[this.embedFeature(values, parent, xindex, xcount)]}',
+                '</tpl>',
+            '{[this.closeRows()]}',
+            '</tbody>',
+        '</table>',
+        '{%if (this.closeTableWrap)out.push(this.closeTableWrap())%}'
+    ],
+
+    constructor: function() {
+        Ext.XTemplate.prototype.recurse = function(values, reference) {
+            return this.apply(reference ? values[reference] : values);
+        };
+    },
+
+    embedFeature: function(values, parent, x, xcount) {
+        var tpl = '';
+        if (!values.disabled) {
+            tpl = values.getFeatureTpl(values, parent, x, xcount);
+        }
+        return tpl;
+    },
+
+    embedFullWidth: function(values) {
+        var result = 'style="width:{fullWidth}px;';
+
+        
+        
+        if (!values.rowCount) {
+            result += 'height:1px;';
+        }
+        return result + '"';
+    },
+
+    openRows: function() {
+        return '<tpl for="rows">';
+    },
+
+    closeRows: function() {
+        return '</tpl>';
+    },
+
+    metaRowTpl: [
+        '<tr class="' + Ext.baseCSSPrefix + 'grid-row {[this.embedRowCls()]}" {[this.embedRowAttr()]}>',
+            '<tpl for="columns">',
+                '<td class="{cls} ' + Ext.baseCSSPrefix + 'grid-cell ' + Ext.baseCSSPrefix + 'grid-cell-{columnId} {{id}-modified} {{id}-tdCls} {[this.firstOrLastCls(xindex, xcount)]}" {{id}-tdAttr}>',
+                    '<div {unselectableAttr} class="' + Ext.baseCSSPrefix + 'grid-cell-inner {unselectableCls}" style="text-align: {align}; {{id}-style};">{{id}}</div>',
+                '</td>',
+            '</tpl>',
+        '</tr>'
+    ],
+
+    firstOrLastCls: function(xindex, xcount) {
+        if (xindex === 1) {
+            return Ext.view.Table.prototype.firstCls;
+        } else if (xindex === xcount) {
+            return Ext.view.Table.prototype.lastCls;
+        }
+    },
+    
+    embedRowCls: function() {
+        return '{rowCls}';
+    },
+    
+    embedRowAttr: function() {
+        return '{rowAttr}';
+    },
+    
+    openTableWrap: undefined,
+    
+    closeTableWrap: undefined,
+
+    getTableTpl: function(cfg, textOnly) {
+        var tpl,
+            tableTplMemberFns = {
+                openRows: this.openRows,
+                closeRows: this.closeRows,
+                embedFeature: this.embedFeature,
+                embedFullWidth: this.embedFullWidth,
+                openTableWrap: this.openTableWrap,
+                closeTableWrap: this.closeTableWrap
+            },
+            tplMemberFns = {},
+            features = cfg.features || [],
+            ln = features.length,
+            i  = 0,
+            memberFns = {
+                embedRowCls: this.embedRowCls,
+                embedRowAttr: this.embedRowAttr,
+                firstOrLastCls: this.firstOrLastCls,
+                unselectableAttr: cfg.enableTextSelection ? '' : 'unselectable="on"',
+                unselectableCls: cfg.enableTextSelection ? '' : Ext.baseCSSPrefix + 'unselectable'
+            },
+            
+            metaRowTpl = Array.prototype.slice.call(this.metaRowTpl, 0),
+            metaTableTpl;
+            
+        for (; i < ln; i++) {
+            if (!features[i].disabled) {
+                features[i].mutateMetaRowTpl(metaRowTpl);
+                Ext.apply(memberFns, features[i].getMetaRowTplFragments());
+                Ext.apply(tplMemberFns, features[i].getFragmentTpl());
+                Ext.apply(tableTplMemberFns, features[i].getTableFragments());
+            }
+        }
+        
+        metaRowTpl = new Ext.XTemplate(metaRowTpl.join(''), memberFns);
+        cfg.row = metaRowTpl.applyTemplate(cfg);
+        
+        metaTableTpl = new Ext.XTemplate(this.metaTableTpl.join(''), tableTplMemberFns);
+        
+        tpl = metaTableTpl.applyTemplate(cfg);
+        
+        
+        if (!textOnly) {
+            tpl = new Ext.XTemplate(tpl, tplMemberFns);
+        }
+        return tpl;
+        
+    }
+});
+
+//@tail
+
+
+
+
+Ext._endTime = new Date().getTime();
+if (Ext._beforereadyhandler){
+    Ext._beforereadyhandler();
+}
diff --git a/test/ext-all.js b/test/ext-all.js
new file mode 100644
index 0000000..46aeaa0
--- /dev/null
+++ b/test/ext-all.js
@@ -0,0 +1,38 @@
+/*
+Ext JS 4.1 - JavaScript Library
+Copyright (c) 2006-2012, Sencha Inc.
+All rights reserved.
+licensing@sencha.com
+
+http://www.sencha.com/license
+
+Open Source License
+------------------------------------------------------------------------------------------
+This version of Ext JS is licensed under the terms of the Open Source GPL 3.0 license. 
+
+http://www.gnu.org/licenses/gpl.html
+
+There are several FLOSS exceptions available for use with this release for
+open source applications that are distributed under a license other than GPL.
+
+* Open Source License Exception for Applications
+
+  http://www.sencha.com/products/floss-exception.php
+
+* Open Source License Exception for Development
+
+  http://www.sencha.com/products/ux-exception.php
+
+
+Alternate Licensing
+------------------------------------------------------------------------------------------
+Commercial and OEM Licenses are available for an alternate download of Ext JS.
+This is the appropriate option if you are creating proprietary applications and you are 
+not prepared to distribute and share the source code of your application under the 
+GPL v3 license. Please visit http://www.sencha.com/license for more details.
+
+--
+
+This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT OF THIRD-PARTY INTELLECTUAL PROPERTY RIGHTS.  See the GNU General Public License for more details.
+*/
+var Ext=Ext||{};Ext._startTime=new Date().getTime();(function(){var h=this,a=Object.prototype,j=a.toString,b=true,g={toString:1},e=function(){},d=function(){var i=d.caller.caller;return i.$owner.prototype[i.$name].apply(this,arguments)},c;Ext.global=h;for(c in g){b=null}if(b){b=["hasOwnProperty","valueOf","isPrototypeOf","propertyIsEnumerable","toLocaleString","toString","constructor"]}Ext.enumerables=b;Ext.apply=function(o,n,q){if(q){Ext.apply(o,q)}if(o&&n&&typeof n==="object"){var p,m,l;for(p in n){o[p]=n[p]}if(b){for(m=b.length;m--;){l=b[m];if(n.hasOwnProperty(l)){o[l]=n[l]}}}}return o};Ext.buildSettings=Ext.apply({baseCSSPrefix:"x-",scopeResetCSS:false},Ext.buildSettings||{});Ext.apply(Ext,{name:Ext.sandboxName||"Ext",emptyFn:e,emptyString:new String(),baseCSSPrefix:Ext.buildSettings.baseCSSPrefix,applyIf:function(k,i){var l;if(k){for(l in i){if(k[l]===undefined){k[l]=i[l]}}}return k},iterate:function(i,l,k){if(Ext.isEmpty(i)){return}if(k===undefined){k=i}if(Ext.isIterable(i)){Ext.Array.each.call(Ext.Array,i,l,k)}else{Ext.Object.each.call(Ext.Object,i,l,k)}}});Ext.apply(Ext,{extend:(function(){var i=a.constructor,k=function(n){for(var l in n){if(!n.hasOwnProperty(l)){continue}this[l]=n[l]}};return function(l,q,o){if(Ext.isObject(q)){o=q;q=l;l=o.constructor!==i?o.constructor:function(){q.apply(this,arguments)}}var n=function(){},m,p=q.prototype;n.prototype=p;m=l.prototype=new n();m.constructor=l;l.superclass=p;if(p.constructor===i){p.constructor=q}l.override=function(r){Ext.override(l,r)};m.override=k;m.proto=m;l.override(o);l.extend=function(r){return Ext.extend(l,r)};return l}}()),override:function(m,n){if(m.$isClass){m.override(n)}else{if(typeof m=="function"){Ext.apply(m.prototype,n)}else{var i=m.self,k,l;if(i&&i.$isClass){for(k in n){if(n.hasOwnProperty(k)){l=n[k];if(typeof l=="function"){l.$name=k;l.$owner=i;l.$previous=m.hasOwnProperty(k)?m[k]:d}m[k]=l}}}else{Ext.apply(m,n)}}}return m}});Ext.apply(Ext,{valueFrom:function(l,i,k){return Ext.isEmpty(l,k)?i:l},typeOf:function(k){var i,l;if(k===null){return"null"}i=typeof k;if(i==="undefined"||i==="string"||i==="number"||i==="boolean"){return i}l=j.call(k);switch(l){case"[object Array]":return"array";case"[object Date]":return"date";case"[object Boolean]":return"boolean";case"[object Number]":return"number";case"[object RegExp]":return"regexp"}if(i==="function"){return"function"}if(i==="object"){if(k.nodeType!==undefined){if(k.nodeType===3){return(/\S/).test(k.nodeValue)?"textnode":"whitespace"}else{return"element"}}return"object"}},isEmpty:function(i,k){return(i===null)||(i===undefined)||(!k?i==="":false)||(Ext.isArray(i)&&i.length===0)},isArray:("isArray" in Array)?Array.isArray:function(i){return j.call(i)==="[object Array]"},isDate:function(i){return j.call(i)==="[object Date]"},isObject:(j.call(null)==="[object Object]")?function(i){return i!==null&&i!==undefined&&j.call(i)==="[object Object]"&&i.ownerDocument===undefined}:function(i){return j.call(i)==="[object Object]"},isSimpleObject:function(i){return i instanceof Object&&i.constructor===Object},isPrimitive:function(k){var i=typeof k;return i==="string"||i==="number"||i==="boolean"},isFunction:(typeof document!=="undefined"&&typeof document.getElementsByTagName("body")==="function")?function(i){return j.call(i)==="[object Function]"}:function(i){return typeof i==="function"},isNumber:function(i){return typeof i==="number"&&isFinite(i)},isNumeric:function(i){return !isNaN(parseFloat(i))&&isFinite(i)},isString:function(i){return typeof i==="string"},isBoolean:function(i){return typeof i==="boolean"},isElement:function(i){return i?i.nodeType===1:false},isTextNode:function(i){return i?i.nodeName==="#text":false},isDefined:function(i){return typeof i!=="undefined"},isIterable:function(k){var i=typeof k,l=false;if(k&&i!="string"){if(i=="function"){if(Ext.isSafari){l=k instanceof NodeList||k instanceof HTMLCollection}}else{l=true}}return l?k.length!==undefined:false}});Ext.apply(Ext,{clone:function(q){var p,o,m,l,r,n;if(q===null||q===undefined){return q}if(q.nodeType&&q.cloneNode){return q.cloneNode(true)}p=j.call(q);if(p==="[object Date]"){return new Date(q.getTime())}if(p==="[object Array]"){o=q.length;r=[];while(o--){r[o]=Ext.clone(q[o])}}else{if(p==="[object Object]"&&q.constructor===Object){r={};for(n in q){r[n]=Ext.clone(q[n])}if(b){for(m=b.length;m--;){l=b[m];r[l]=q[l]}}}}return r||q},getUniqueGlobalNamespace:function(){var l=this.uniqueGlobalNamespace,k;if(l===undefined){k=0;do{l="ExtBox"+(++k)}while(Ext.global[l]!==undefined);Ext.global[l]=Ext;this.uniqueGlobalNamespace=l}return l},functionFactoryCache:{},cacheableFunctionFactory:function(){var o=this,l=Array.prototype.slice.call(arguments),k=o.functionFactoryCache,i,m,n;if(Ext.isSandboxed){n=l.length;if(n>0){n--;l[n]="var Ext=window."+Ext.name+";"+l[n]}}i=l.join("");m=k[i];if(!m){m=Function.prototype.constructor.apply(Function.prototype,l);k[i]=m}return m},functionFactory:function(){var l=this,i=Array.prototype.slice.call(arguments),k;if(Ext.isSandboxed){k=i.length;if(k>0){k--;i[k]="var Ext=window."+Ext.name+";"+i[k]}}return Function.prototype.constructor.apply(Function.prototype,i)},Logger:{verbose:e,log:e,info:e,warn:e,error:function(i){throw new Error(i)},deprecate:e}});Ext.type=Ext.typeOf}());Ext.globalEval=Ext.global.execScript?function(a){execScript(a)}:function($$code){(function(){eval($$code)}())};(function(){var a="4.1.1.1",b;Ext.Version=b=Ext.extend(Object,{constructor:function(c){var e,d;if(c instanceof b){return c}this.version=this.shortVersion=String(c).toLowerCase().replace(/_/g,".").replace(/[\-+]/g,"");d=this.version.search(/([^\d\.])/);if(d!==-1){this.release=this.version.substr(d,c.length);this.shortVersion=this.version.substr(0,d)}this.shortVersion=this.shortVersion.replace(/[^\d]/g,"");e=this.version.split(".");this.major=parseInt(e.shift()||0,10);this.minor=parseInt(e.shift()||0,10);this.patch=parseInt(e.shift()||0,10);this.build=parseInt(e.shift()||0,10);return this},toString:function(){return this.version},valueOf:function(){return this.version},getMajor:function(){return this.major||0},getMinor:function(){return this.minor||0},getPatch:function(){return this.patch||0},getBuild:function(){return this.build||0},getRelease:function(){return this.release||""},isGreaterThan:function(c){return b.compare(this.version,c)===1},isGreaterThanOrEqual:function(c){return b.compare(this.version,c)>=0},isLessThan:function(c){return b.compare(this.version,c)===-1},isLessThanOrEqual:function(c){return b.compare(this.version,c)<=0},equals:function(c){return b.compare(this.version,c)===0},match:function(c){c=String(c);return this.version.substr(0,c.length)===c},toArray:function(){return[this.getMajor(),this.getMinor(),this.getPatch(),this.getBuild(),this.getRelease()]},getShortVersion:function(){return this.shortVersion},gt:function(){return this.isGreaterThan.apply(this,arguments)},lt:function(){return this.isLessThan.apply(this,arguments)},gtEq:function(){return this.isGreaterThanOrEqual.apply(this,arguments)},ltEq:function(){return this.isLessThanOrEqual.apply(this,arguments)}});Ext.apply(b,{releaseValueMap:{dev:-6,alpha:-5,a:-5,beta:-4,b:-4,rc:-3,"#":-2,p:-1,pl:-1},getComponentValue:function(c){return !c?0:(isNaN(c)?this.releaseValueMap[c]||c:parseInt(c,10))},compare:function(h,g){var d,e,c;h=new b(h).toArray();g=new b(g).toArray();for(c=0;c<Math.max(h.length,g.length);c++){d=this.getComponentValue(h[c]);e=this.getComponentValue(g[c]);if(d<e){return -1}else{if(d>e){return 1}}}return 0}});Ext.apply(Ext,{versions:{},lastRegisteredVersion:null,setVersion:function(d,c){Ext.versions[d]=new b(c);Ext.lastRegisteredVersion=Ext.versions[d];return this},getVersion:function(c){if(c===undefined){return Ext.lastRegisteredVersion}return Ext.versions[c]},deprecate:function(c,e,g,d){if(b.compare(Ext.getVersion(c),e)<1){g.call(d)}}});Ext.setVersion("core",a)}());Ext.String=(function(){var i=/^[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]+|[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]+$/g,m=/('|\\)/g,h=/\{(\d+)\}/g,b=/([-.*+?\^${}()|\[\]\/\\])/g,n=/^\s+|\s+$/g,j=/\s+/,l=/(^[^a-z]*|[^\w])/gi,d,a,g,c,e=function(p,o){return d[o]},k=function(p,o){return(o in a)?a[o]:String.fromCharCode(parseInt(o.substr(2),10))};return{createVarName:function(o){return o.replace(l,"")},htmlEncode:function(o){return(!o)?o:String(o).replace(g,e)},htmlDecode:function(o){return(!o)?o:String(o).replace(c,k)},addCharacterEntities:function(p){var o=[],s=[],q,r;for(q in p){r=p[q];a[q]=r;d[r]=q;o.push(r);s.push(q)}g=new RegExp("("+o.join("|")+")","g");c=new RegExp("("+s.join("|")+"|&#[0-9]{1,5};)","g")},resetCharacterEntities:function(){d={};a={};this.addCharacterEntities({"&amp;":"&","&gt;":">","&lt;":"<","&quot;":'"',"&#39;":"'"})},urlAppend:function(p,o){if(!Ext.isEmpty(o)){return p+(p.indexOf("?")===-1?"?":"&")+o}return p},trim:function(o){return o.replace(i,"")},capitalize:function(o){return o.charAt(0).toUpperCase()+o.substr(1)},uncapitalize:function(o){return o.charAt(0).toLowerCase()+o.substr(1)},ellipsis:function(q,o,r){if(q&&q.length>o){if(r){var s=q.substr(0,o-2),p=Math.max(s.lastIndexOf(" "),s.lastIndexOf("."),s.lastIndexOf("!"),s.lastIndexOf("?"));if(p!==-1&&p>=(o-15)){return s.substr(0,p)+"..."}}return q.substr(0,o-3)+"..."}return q},escapeRegex:function(o){return o.replace(b,"\\$1")},escape:function(o){return o.replace(m,"\\$1")},toggle:function(p,q,o){return p===q?o:q},leftPad:function(p,q,r){var o=String(p);r=r||" ";while(o.length<q){o=r+o}return o},format:function(p){var o=Ext.Array.toArray(arguments,1);return p.replace(h,function(q,r){return o[r]})},repeat:function(s,r,p){for(var o=[],q=r;q--;){o.push(s)}return o.join(p||"")},splitWords:function(o){if(o&&typeof o=="string"){return o.replace(n,"").split(j)}return o||[]}}}());Ext.String.resetCharacterEntities();Ext.htmlEncode=Ext.String.htmlEncode;Ext.htmlDecode=Ext.String.htmlDecode;Ext.urlAppend=Ext.String.urlAppend;Ext.Number=new function(){var b=this,c=(0.9).toFixed()!=="1",a=Math;Ext.apply(this,{constrain:function(h,g,e){var d=parseFloat(h);return(d<g)?g:((d>e)?e:d)},snap:function(h,e,g,i){var d;if(h===undefined||h<g){return g||0}if(e){d=h%e;if(d!==0){h-=d;if(d*2>=e){h+=e}else{if(d*2<-e){h-=e}}}}return b.constrain(h,g,i)},snapInRange:function(h,d,g,i){var e;g=(g||0);if(h===undefined||h<g){return g}if(d&&(e=((h-g)%d))){h-=e;e*=2;if(e>=d){h+=d}}if(i!==undefined){if(h>(i=b.snapInRange(i,d,g))){h=i}}return h},toFixed:c?function(g,d){d=d||0;var e=a.pow(10,d);return(a.round(g*e)/e).toFixed(d)}:function(e,d){return e.toFixed(d)},from:function(e,d){if(isFinite(e)){e=parseFloat(e)}return !isNaN(e)?e:d},randomInt:function(e,d){return a.floor(a.random()*(d-e+1)+e)}});Ext.num=function(){return b.from.apply(this,arguments)}};(function(){var g=Array.prototype,o=g.slice,q=(function(){var A=[],e,z=20;if(!A.splice){return false}while(z--){A.push("A")}A.splice(15,0,"F","F","F","F","F","F","F","F","F","F","F","F","F","F","F","F","F","F","F","F","F");e=A.length;A.splice(13,0,"XXX");if(e+1!=A.length){return false}return true}()),j="forEach" in g,u="map" in g,p="indexOf" in g,y="every" in g,c="some" in g,d="filter" in g,n=(function(){var e=[1,2,3,4,5].sort(function(){return 0});return e[0]===1&&e[1]===2&&e[2]===3&&e[3]===4&&e[4]===5}()),k=true,a,w,t,v;try{if(typeof document!=="undefined"){o.call(document.getElementsByTagName("body"))}}catch(s){k=false}function m(z,e){return(e<0)?Math.max(0,z.length+e):Math.min(z.length,e)}function x(G,F,z,J){var K=J?J.length:0,B=G.length,H=m(G,F),E,I,A,e,C,D;if(H===B){if(K){G.push.apply(G,J)}}else{E=Math.min(z,B-H);I=H+E;A=I+K-E;e=B-I;C=B-E;if(A<I){for(D=0;D<e;++D){G[A+D]=G[I+D]}}else{if(A>I){for(D=e;D--;){G[A+D]=G[I+D]}}}if(K&&H===C){G.length=C;G.push.apply(G,J)}else{G.length=C+K;for(D=0;D<K;++D){G[H+D]=J[D]}}}return G}function i(B,e,A,z){if(z&&z.length){if(e<B.length){B.splice.apply(B,[e,A].concat(z))}else{B.push.apply(B,z)}}else{B.splice(e,A)}return B}function b(A,e,z){return x(A,e,z)}function r(A,e,z){A.splice(e,z);return A}function l(C,e,A){var B=m(C,e),z=C.slice(e,m(C,B+A));if(arguments.length<4){x(C,B,A)}else{x(C,B,A,o.call(arguments,3))}return z}function h(e){return e.splice.apply(e,o.call(arguments,1))}w=q?r:b;t=q?i:x;v=q?h:l;a=Ext.Array={each:function(D,B,A,e){D=a.from(D);var z,C=D.length;if(e!==true){for(z=0;z<C;z++){if(B.call(A||D[z],D[z],z,D)===false){return z}}}else{for(z=C-1;z>-1;z--){if(B.call(A||D[z],D[z],z,D)===false){return z}}}return true},forEach:j?function(A,z,e){return A.forEach(z,e)}:function(C,A,z){var e=0,B=C.length;for(;e<B;e++){A.call(z,C[e],e,C)}},indexOf:p?function(A,e,z){return A.indexOf(e,z)}:function(C,A,B){var e,z=C.length;for(e=(B<0)?Math.max(0,z+B):B||0;e<z;e++){if(C[e]===A){return e}}return -1},contains:p?function(z,e){return z.indexOf(e)!==-1}:function(B,A){var e,z;for(e=0,z=B.length;e<z;e++){if(B[e]===A){return true}}return false},toArray:function(A,C,e){if(!A||!A.length){return[]}if(typeof A==="string"){A=A.split("")}if(k){return o.call(A,C||0,e||A.length)}var B=[],z;C=C||0;e=e?((e<0)?A.length+e:e):A.length;for(z=C;z<e;z++){B.push(A[z])}return B},pluck:function(D,e){var z=[],A,C,B;for(A=0,C=D.length;A<C;A++){B=D[A];z.push(B[e])}return z},map:u?function(A,z,e){return A.map(z,e)}:function(D,C,B){var A=[],z=0,e=D.length;for(;z<e;z++){A[z]=C.call(B,D[z],z,D)}return A},every:y?function(A,z,e){return A.every(z,e)}:function(C,A,z){var e=0,B=C.length;for(;e<B;++e){if(!A.call(z,C[e],e,C)){return false}}return true},some:c?function(A,z,e){return A.some(z,e)}:function(C,A,z){var e=0,B=C.length;for(;e<B;++e){if(A.call(z,C[e],e,C)){return true}}return false},clean:function(C){var z=[],e=0,B=C.length,A;for(;e<B;e++){A=C[e];if(!Ext.isEmpty(A)){z.push(A)}}return z},unique:function(C){var B=[],e=0,A=C.length,z;for(;e<A;e++){z=C[e];if(a.indexOf(B,z)===-1){B.push(z)}}return B},filter:d?function(A,z,e){return A.filter(z,e)}:function(D,B,A){var z=[],e=0,C=D.length;for(;e<C;e++){if(B.call(A,D[e],e,D)){z.push(D[e])}}return z},from:function(A,z){if(A===undefined||A===null){return[]}if(Ext.isArray(A)){return(z)?o.call(A):A}var e=typeof A;if(A&&A.length!==undefined&&e!=="string"&&(e!=="function"||!A.apply)){return a.toArray(A)}return[A]},remove:function(A,z){var e=a.indexOf(A,z);if(e!==-1){w(A,e,1)}return A},include:function(z,e){if(!a.contains(z,e)){z.push(e)}},clone:function(e){return o.call(e)},merge:function(){var e=o.call(arguments),B=[],z,A;for(z=0,A=e.length;z<A;z++){B=B.concat(e[z])}return a.unique(B)},intersect:function(){var e=[],A=o.call(arguments),L,J,F,I,M,B,z,H,K,C,G,E,D;if(!A.length){return e}L=A.length;for(G=M=0;G<L;G++){B=A[G];if(!I||B.length<I.length){I=B;M=G}}I=a.unique(I);w(A,M,1);z=I.length;L=A.length;for(G=0;G<z;G++){H=I[G];C=0;for(E=0;E<L;E++){J=A[E];F=J.length;for(D=0;D<F;D++){K=J[D];if(H===K){C++;break}}}if(C===L){e.push(H)}}return e},difference:function(z,e){var E=o.call(z),C=E.length,B,A,D;for(B=0,D=e.length;B<D;B++){for(A=0;A<C;A++){if(E[A]===e[B]){w(E,A,1);A--;C--}}}return E},slice:([1,2].slice(1,undefined).length?function(A,z,e){return o.call(A,z,e)}:function(A,z,e){if(typeof z==="undefined"){return o.call(A)}if(typeof e==="undefined"){return o.call(A,z)}return o.call(A,z,e)}),sort:n?function(z,e){if(e){return z.sort(e)}else{return z.sort()}}:function(F,E){var C=F.length,B=0,D,e,A,z;for(;B<C;B++){A=B;for(e=B+1;e<C;e++){if(E){D=E(F[e],F[A]);if(D<0){A=e}}else{if(F[e]<F[A]){A=e}}}if(A!==B){z=F[B];F[B]=F[A];F[A]=z}}return F},flatten:function(A){var z=[];function e(B){var D,E,C;for(D=0,E=B.length;D<E;D++){C=B[D];if(Ext.isArray(C)){e(C)}else{z.push(C)}}return z}return e(A)},min:function(D,C){var z=D[0],e,B,A;for(e=0,B=D.length;e<B;e++){A=D[e];if(C){if(C(z,A)===1){z=A}}else{if(A<z){z=A}}}return z},max:function(D,C){var e=D[0],z,B,A;for(z=0,B=D.length;z<B;z++){A=D[z];if(C){if(C(e,A)===-1){e=A}}else{if(A>e){e=A}}}return e},mean:function(e){return e.length>0?a.sum(e)/e.length:undefined},sum:function(C){var z=0,e,B,A;for(e=0,B=C.length;e<B;e++){A=C[e];z+=A}return z},toMap:function(C,e,A){var B={},z=C.length;if(!e){while(z--){B[C[z]]=z+1}}else{if(typeof e=="string"){while(z--){B[C[z][e]]=z+1}}else{while(z--){B[e.call(A,C[z])]=z+1}}}return B},erase:w,insert:function(A,z,e){return t(A,z,0,e)},replace:t,splice:v,push:function(B){var e=arguments.length,A=1,z;if(B===undefined){B=[]}else{if(!Ext.isArray(B)){B=[B]}}for(;A<e;A++){z=arguments[A];Array.prototype.push[Ext.isArray(z)?"apply":"call"](B,z)}return B}};Ext.each=a.each;a.union=a.merge;Ext.min=a.min;Ext.max=a.max;Ext.sum=a.sum;Ext.mean=a.mean;Ext.flatten=a.flatten;Ext.clean=a.clean;Ext.unique=a.unique;Ext.pluck=a.pluck;Ext.toArray=function(){return a.toArray.apply(a,arguments)}}());Ext.Function={flexSetter:function(a){return function(d,c){var e,g;if(d===null){return this}if(typeof d!=="string"){for(e in d){if(d.hasOwnProperty(e)){a.call(this,e,d[e])}}if(Ext.enumerables){for(g=Ext.enumerables.length;g--;){e=Ext.enumerables[g];if(d.hasOwnProperty(e)){a.call(this,e,d[e])}}}}else{a.call(this,d,c)}return this}},bind:function(d,c,b,a){if(arguments.length===2){return function(){return d.apply(c,arguments)}}var g=d,e=Array.prototype.slice;return function(){var h=b||arguments;if(a===true){h=e.call(arguments,0);h=h.concat(b)}else{if(typeof a=="number"){h=e.call(arguments,0);Ext.Array.insert(h,a,b)}}return g.apply(c||Ext.global,h)}},pass:function(c,a,b){if(!Ext.isArray(a)){if(Ext.isIterable(a)){a=Ext.Array.clone(a)}else{a=a!==undefined?[a]:[]}}return function(){var d=[].concat(a);d.push.apply(d,arguments);return c.apply(b||this,d)}},alias:function(b,a){return function(){return b[a].apply(b,arguments)}},clone:function(a){return function(){return a.apply(this,arguments)}},createInterceptor:function(d,c,b,a){var e=d;if(!Ext.isFunction(c)){return d}else{return function(){var h=this,g=arguments;c.target=h;c.method=d;return(c.apply(b||h||Ext.global,g)!==false)?d.apply(h||Ext.global,g):a||null}}},createDelayed:function(e,c,d,b,a){if(d||b){e=Ext.Function.bind(e,d,b,a)}return function(){var h=this,g=Array.prototype.slice.call(arguments);setTimeout(function(){e.apply(h,g)},c)}},defer:function(e,c,d,b,a){e=Ext.Function.bind(e,d,b,a);if(c>0){return setTimeout(Ext.supports.TimeoutActualLateness?function(){e()}:e,c)}e();return 0},createSequence:function(b,c,a){if(!c){return b}else{return function(){var d=b.apply(this,arguments);c.apply(a||this,arguments);return d}}},createBuffered:function(e,b,d,c){var a;return function(){var h=c||Array.prototype.slice.call(arguments,0),g=d||this;if(a){clearTimeout(a)}a=setTimeout(function(){e.apply(g,h)},b)}},createThrottled:function(e,b,d){var g,a,c,i,h=function(){e.apply(d||this,c);g=new Date().getTime()};return function(){a=new Date().getTime()-g;c=arguments;clearTimeout(i);if(!g||(a>=b)){h()}else{i=setTimeout(h,b-a)}}},interceptBefore:function(b,a,d,c){var e=b[a]||Ext.emptyFn;return(b[a]=function(){var g=d.apply(c||this,arguments);e.apply(this,arguments);return g})},interceptAfter:function(b,a,d,c){var e=b[a]||Ext.emptyFn;return(b[a]=function(){e.apply(this,arguments);return d.apply(c||this,arguments)})}};Ext.defer=Ext.Function.alias(Ext.Function,"defer");Ext.pass=Ext.Function.alias(Ext.Function,"pass");Ext.bind=Ext.Function.alias(Ext.Function,"bind");(function(){var a=function(){},b=Ext.Object={chain:function(d){a.prototype=d;var c=new a();a.prototype=null;return c},toQueryObjects:function(e,k,d){var c=b.toQueryObjects,j=[],g,h;if(Ext.isArray(k)){for(g=0,h=k.length;g<h;g++){if(d){j=j.concat(c(e+"["+g+"]",k[g],true))}else{j.push({name:e,value:k[g]})}}}else{if(Ext.isObject(k)){for(g in k){if(k.hasOwnProperty(g)){if(d){j=j.concat(c(e+"["+g+"]",k[g],true))}else{j.push({name:e,value:k[g]})}}}}else{j.push({name:e,value:k})}}return j},toQueryString:function(g,d){var h=[],e=[],l,k,m,c,n;for(l in g){if(g.hasOwnProperty(l)){h=h.concat(b.toQueryObjects(l,g[l],d))}}for(k=0,m=h.length;k<m;k++){c=h[k];n=c.value;if(Ext.isEmpty(n)){n=""}else{if(Ext.isDate(n)){n=Ext.Date.toString(n)}}e.push(encodeURIComponent(c.name)+"="+encodeURIComponent(String(n)))}return e.join("&")},fromQueryString:function(d,r){var m=d.replace(/^\?/,"").split("&"),u={},s,k,w,n,q,g,o,p,c,h,t,l,v,e;for(q=0,g=m.length;q<g;q++){o=m[q];if(o.length>0){k=o.split("=");w=decodeURIComponent(k[0]);n=(k[1]!==undefined)?decodeURIComponent(k[1]):"";if(!r){if(u.hasOwnProperty(w)){if(!Ext.isArray(u[w])){u[w]=[u[w]]}u[w].push(n)}else{u[w]=n}}else{h=w.match(/(\[):?([^\]]*)\]/g);t=w.match(/^([^\[]+)/);w=t[0];l=[];if(h===null){u[w]=n;continue}for(p=0,c=h.length;p<c;p++){v=h[p];v=(v.length===2)?"":v.substring(1,v.length-1);l.push(v)}l.unshift(w);s=u;for(p=0,c=l.length;p<c;p++){v=l[p];if(p===c-1){if(Ext.isArray(s)&&v===""){s.push(n)}else{s[v]=n}}else{if(s[v]===undefined||typeof s[v]==="string"){e=l[p+1];s[v]=(Ext.isNumeric(e)||e==="")?[]:{}}s=s[v]}}}}}return u},each:function(c,e,d){for(var g in c){if(c.hasOwnProperty(g)){if(e.call(d||c,g,c[g],c)===false){return}}}},merge:function(k){var h=1,j=arguments.length,c=b.merge,e=Ext.clone,g,m,l,d;for(;h<j;h++){g=arguments[h];for(m in g){l=g[m];if(l&&l.constructor===Object){d=k[m];if(d&&d.constructor===Object){c(d,l)}else{k[m]=e(l)}}else{k[m]=l}}}return k},mergeIf:function(c){var h=1,j=arguments.length,e=Ext.clone,d,g,k;for(;h<j;h++){d=arguments[h];for(g in d){if(!(g in c)){k=d[g];if(k&&k.constructor===Object){c[g]=e(k)}else{c[g]=k}}}}return c},getKey:function(c,e){for(var d in c){if(c.hasOwnProperty(d)&&c[d]===e){return d}}return null},getValues:function(d){var c=[],e;for(e in d){if(d.hasOwnProperty(e)){c.push(d[e])}}return c},getKeys:(typeof Object.keys=="function")?function(c){if(!c){return[]}return Object.keys(c)}:function(c){var d=[],e;for(e in c){if(c.hasOwnProperty(e)){d.push(e)}}return d},getSize:function(c){var d=0,e;for(e in c){if(c.hasOwnProperty(e)){d++}}return d},classify:function(g){var e=g,i=[],d={},c=function(){var k=0,l=i.length,m;for(;k<l;k++){m=i[k];this[m]=new d[m]()}},h,j;for(h in g){if(g.hasOwnProperty(h)){j=g[h];if(j&&j.constructor===Object){i.push(h);d[h]=b.classify(j)}}}c.prototype=e;return c}};Ext.merge=Ext.Object.merge;Ext.mergeIf=Ext.Object.mergeIf;Ext.urlEncode=function(){var c=Ext.Array.from(arguments),d="";if((typeof c[1]==="string")){d=c[1]+"&";c[1]=false}return d+b.toQueryString.apply(b,c)};Ext.urlDecode=function(){return b.fromQueryString.apply(b,arguments)}}());(function(){function b(d){var c=Array.prototype.slice.call(arguments,1);return d.replace(/\{(\d+)\}/g,function(e,g){return c[g]})}Ext.Date={now:Date.now||function(){return +new Date()},toString:function(c){var d=Ext.String.leftPad;return c.getFullYear()+"-"+d(c.getMonth()+1,2,"0")+"-"+d(c.getDate(),2,"0")+"T"+d(c.getHours(),2,"0")+":"+d(c.getMinutes(),2,"0")+":"+d(c.getSeconds(),2,"0")},getElapsed:function(d,c){return Math.abs(d-(c||new Date()))},useStrict:false,formatCodeToRegex:function(d,c){var e=a.parseCodes[d];if(e){e=typeof e=="function"?e():e;a.parseCodes[d]=e}return e?Ext.applyIf({c:e.c?b(e.c,c||"{0}"):e.c},e):{g:0,c:null,s:Ext.String.escapeRegex(d)}},parseFunctions:{MS:function(d,c){var e=new RegExp("\\/Date\\(([-+])?(\\d+)(?:[+-]\\d{4})?\\)\\/"),g=(d||"").match(e);return g?new Date(((g[1]||"")+g[2])*1):null}},parseRegexes:[],formatFunctions:{MS:function(){return"\\/Date("+this.getTime()+")\\/"}},y2kYear:50,MILLI:"ms",SECOND:"s",MINUTE:"mi",HOUR:"h",DAY:"d",MONTH:"mo",YEAR:"y",defaults:{},dayNames:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],monthNames:["January","February","March","April","May","June","July","August","September","October","November","December"],monthNumbers:{January:0,Jan:0,February:1,Feb:1,March:2,Mar:2,April:3,Apr:3,May:4,June:5,Jun:5,July:6,Jul:6,August:7,Aug:7,September:8,Sep:8,October:9,Oct:9,November:10,Nov:10,December:11,Dec:11},defaultFormat:"m/d/Y",getShortMonthName:function(c){return Ext.Date.monthNames[c].substring(0,3)},getShortDayName:function(c){return Ext.Date.dayNames[c].substring(0,3)},getMonthNumber:function(c){return Ext.Date.monthNumbers[c.substring(0,1).toUpperCase()+c.substring(1,3).toLowerCase()]},formatContainsHourInfo:(function(){var d=/(\\.)/g,c=/([gGhHisucUOPZ]|MS)/;return function(e){return c.test(e.replace(d,""))}}()),formatContainsDateInfo:(function(){var d=/(\\.)/g,c=/([djzmnYycU]|MS)/;return function(e){return c.test(e.replace(d,""))}}()),unescapeFormat:(function(){var c=/\\/gi;return function(d){return d.replace(c,"")}}()),formatCodes:{d:"Ext.String.leftPad(this.getDate(), 2, '0')",D:"Ext.Date.getShortDayName(this.getDay())",j:"this.getDate()",l:"Ext.Date.dayNames[this.getDay()]",N:"(this.getDay() ? this.getDay() : 7)",S:"Ext.Date.getSuffix(this)",w:"this.getDay()",z:"Ext.Date.getDayOfYear(this)",W:"Ext.String.leftPad(Ext.Date.getWeekOfYear(this), 2, '0')",F:"Ext.Date.monthNames[this.getMonth()]",m:"Ext.String.leftPad(this.getMonth() + 1, 2, '0')",M:"Ext.Date.getShortMonthName(this.getMonth())",n:"(this.getMonth() + 1)",t:"Ext.Date.getDaysInMonth(this)",L:"(Ext.Date.isLeapYear(this) ? 1 : 0)",o:"(this.getFullYear() + (Ext.Date.getWeekOfYear(this) == 1 && this.getMonth() > 0 ? +1 : (Ext.Date.getWeekOfYear(this) >= 52 && this.getMonth() < 11 ? -1 : 0)))",Y:"Ext.String.leftPad(this.getFullYear(), 4, '0')",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:"Ext.String.leftPad((this.getHours() % 12) ? this.getHours() % 12 : 12, 2, '0')",H:"Ext.String.leftPad(this.getHours(), 2, '0')",i:"Ext.String.leftPad(this.getMinutes(), 2, '0')",s:"Ext.String.leftPad(this.getSeconds(), 2, '0')",u:"Ext.String.leftPad(this.getMilliseconds(), 3, '0')",O:"Ext.Date.getGMTOffset(this)",P:"Ext.Date.getGMTOffset(this, true)",T:"Ext.Date.getTimezone(this)",Z:"(this.getTimezoneOffset() * -60)",c:function(){var k,h,g,d,j;for(k="Y-m-dTH:i:sP",h=[],g=0,d=k.length;g<d;++g){j=k.charAt(g);h.push(j=="T"?"'T'":a.getFormatCode(j))}return h.join(" + ")},U:"Math.round(this.getTime() / 1000)"},isValid:function(o,c,n,k,g,j,e){k=k||0;g=g||0;j=j||0;e=e||0;var l=a.add(new Date(o<100?100:o,c-1,n,k,g,j,e),a.YEAR,o<100?o-100:0);return o==l.getFullYear()&&c==l.getMonth()+1&&n==l.getDate()&&k==l.getHours()&&g==l.getMinutes()&&j==l.getSeconds()&&e==l.getMilliseconds()},parse:function(d,g,c){var e=a.parseFunctions;if(e[g]==null){a.createParser(g)}return e[g](d,Ext.isDefined(c)?c:a.useStrict)},parseDate:function(d,e,c){return a.parse(d,e,c)},getFormatCode:function(d){var c=a.formatCodes[d];if(c){c=typeof c=="function"?c():c;a.formatCodes[d]=c}return c||("'"+Ext.String.escape(d)+"'")},createFormat:function(h){var g=[],c=false,e="",d;for(d=0;d<h.length;++d){e=h.charAt(d);if(!c&&e=="\\"){c=true}else{if(c){c=false;g.push("'"+Ext.String.escape(e)+"'")}else{g.push(a.getFormatCode(e))}}}a.formatFunctions[h]=Ext.functionFactory("return "+g.join("+"))},createParser:(function(){var c=["var dt, y, m, d, h, i, s, ms, o, z, zz, u, v,","def = Ext.Date.defaults,","results = String(input).match(Ext.Date.parseRegexes[{0}]);","if(results){","{1}","if(u != null){","v = new Date(u * 1000);","}else{","dt = Ext.Date.clearTime(new Date);","y = Ext.Number.from(y, Ext.Number.from(def.y, dt.getFullYear()));","m = Ext.Number.from(m, Ext.Number.from(def.m - 1, dt.getMonth()));","d = Ext.Number.from(d, Ext.Number.from(def.d, dt.getDate()));","h  = Ext.Number.from(h, Ext.Number.from(def.h, dt.getHours()));","i  = Ext.Number.from(i, Ext.Number.from(def.i, dt.getMinutes()));","s  = Ext.Number.from(s, Ext.Number.from(def.s, dt.getSeconds()));","ms = Ext.Number.from(ms, Ext.Number.from(def.ms, dt.getMilliseconds()));","if(z >= 0 && y >= 0){","v = Ext.Date.add(new Date(y < 100 ? 100 : y, 0, 1, h, i, s, ms), Ext.Date.YEAR, y < 100 ? y - 100 : 0);","v = !strict? v : (strict === true && (z <= 364 || (Ext.Date.isLeapYear(v) && z <= 365))? Ext.Date.add(v, Ext.Date.DAY, z) : null);","}else if(strict === true && !Ext.Date.isValid(y, m + 1, d, h, i, s, ms)){","v = null;","}else{","v = Ext.Date.add(new Date(y < 100 ? 100 : y, m, d, h, i, s, ms), Ext.Date.YEAR, y < 100 ? y - 100 : 0);","}","}","}","if(v){","if(zz != null){","v = Ext.Date.add(v, Ext.Date.SECOND, -v.getTimezoneOffset() * 60 - zz);","}else if(o){","v = Ext.Date.add(v, Ext.Date.MINUTE, -v.getTimezoneOffset() + (sn == '+'? -1 : 1) * (hr * 60 + mn));","}","}","return v;"].join("\n");return function(o){var e=a.parseRegexes.length,p=1,g=[],n=[],l=false,d="",j=0,k=o.length,m=[],h;for(;j<k;++j){d=o.charAt(j);if(!l&&d=="\\"){l=true}else{if(l){l=false;n.push(Ext.String.escape(d))}else{h=a.formatCodeToRegex(d,p);p+=h.g;n.push(h.s);if(h.g&&h.c){if(h.calcAtEnd){m.push(h.c)}else{g.push(h.c)}}}}}g=g.concat(m);a.parseRegexes[e]=new RegExp("^"+n.join("")+"$","i");a.parseFunctions[o]=Ext.functionFactory("input","strict",b(c,e,g.join("")))}}()),parseCodes:{d:{g:1,c:"d = parseInt(results[{0}], 10);\n",s:"(3[0-1]|[1-2][0-9]|0[1-9])"},j:{g:1,c:"d = parseInt(results[{0}], 10);\n",s:"(3[0-1]|[1-2][0-9]|[1-9])"},D:function(){for(var c=[],d=0;d<7;c.push(a.getShortDayName(d)),++d){}return{g:0,c:null,s:"(?:"+c.join("|")+")"}},l:function(){return{g:0,c:null,s:"(?:"+a.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:1,c:"z = parseInt(results[{0}], 10);\n",s:"(\\d{1,3})"},W:{g:0,c:null,s:"(?:\\d{2})"},F:function(){return{g:1,c:"m = parseInt(Ext.Date.getMonthNumber(results[{0}]), 10);\n",s:"("+a.monthNames.join("|")+")"}},M:function(){for(var c=[],d=0;d<12;c.push(a.getShortMonthName(d)),++d){}return Ext.applyIf({s:"("+c.join("|")+")"},a.formatCodeToRegex("F"))},m:{g:1,c:"m = parseInt(results[{0}], 10) - 1;\n",s:"(1[0-2]|0[1-9])"},n:{g:1,c:"m = parseInt(results[{0}], 10) - 1;\n",s:"(1[0-2]|[1-9])"},t:{g:0,c:null,s:"(?:\\d{2})"},L:{g:0,c:null,s:"(?:1|0)"},o:function(){return a.formatCodeToRegex("Y")},Y:{g:1,c:"y = parseInt(results[{0}], 10);\n",s:"(\\d{4})"},y:{g:1,c:"var ty = parseInt(results[{0}], 10);\ny = ty > Ext.Date.y2kYear ? 1900 + ty : 2000 + ty;\n",s:"(\\d{1,2})"},a:{g:1,c:"if (/(am)/i.test(results[{0}])) {\nif (!h || h == 12) { h = 0; }\n} else { if (!h || h < 12) { h = (h || 0) + 12; }}",s:"(am|pm|AM|PM)",calcAtEnd:true},A:{g:1,c:"if (/(am)/i.test(results[{0}])) {\nif (!h || h == 12) { h = 0; }\n} else { if (!h || h < 12) { h = (h || 0) + 12; }}",s:"(AM|PM|am|pm)",calcAtEnd:true},g:{g:1,c:"h = parseInt(results[{0}], 10);\n",s:"(1[0-2]|[0-9])"},G:{g:1,c:"h = parseInt(results[{0}], 10);\n",s:"(2[0-3]|1[0-9]|[0-9])"},h:{g:1,c:"h = parseInt(results[{0}], 10);\n",s:"(1[0-2]|0[1-9])"},H:{g:1,c:"h = parseInt(results[{0}], 10);\n",s:"(2[0-3]|[0-1][0-9])"},i:{g:1,c:"i = parseInt(results[{0}], 10);\n",s:"([0-5][0-9])"},s:{g:1,c:"s = parseInt(results[{0}], 10);\n",s:"([0-5][0-9])"},u:{g:1,c:"ms = results[{0}]; ms = parseInt(ms, 10)/Math.pow(10, ms.length - 3);\n",s:"(\\d+)"},O:{g:1,c:["o = results[{0}];","var sn = o.substring(0,1),","hr = o.substring(1,3)*1 + Math.floor(o.substring(3,5) / 60),","mn = o.substring(3,5) % 60;","o = ((-12 <= (hr*60 + mn)/60) && ((hr*60 + mn)/60 <= 14))? (sn + Ext.String.leftPad(hr, 2, '0') + Ext.String.leftPad(mn, 2, '0')) : null;\n"].join("\n"),s:"([+-]\\d{4})"},P:{g:1,c:["o = results[{0}];","var sn = o.substring(0,1),","hr = o.substring(1,3)*1 + Math.floor(o.substring(4,6) / 60),","mn = o.substring(4,6) % 60;","o = ((-12 <= (hr*60 + mn)/60) && ((hr*60 + mn)/60 <= 14))? (sn + Ext.String.leftPad(hr, 2, '0') + Ext.String.leftPad(mn, 2, '0')) : null;\n"].join("\n"),s:"([+-]\\d{2}:\\d{2})"},T:{g:0,c:null,s:"[A-Z]{1,4}"},Z:{g:1,c:"zz = results[{0}] * 1;\nzz = (-43200 <= zz && zz <= 50400)? zz : null;\n",s:"([+-]?\\d{1,5})"},c:function(){var e=[],c=[a.formatCodeToRegex("Y",1),a.formatCodeToRegex("m",2),a.formatCodeToRegex("d",3),a.formatCodeToRegex("H",4),a.formatCodeToRegex("i",5),a.formatCodeToRegex("s",6),{c:"ms = results[7] || '0'; ms = parseInt(ms, 10)/Math.pow(10, ms.length - 3);\n"},{c:["if(results[8]) {","if(results[8] == 'Z'){","zz = 0;","}else if (results[8].indexOf(':') > -1){",a.formatCodeToRegex("P",8).c,"}else{",a.formatCodeToRegex("O",8).c,"}","}"].join("\n")}],g,d;for(g=0,d=c.length;g<d;++g){e.push(c[g].c)}return{g:1,c:e.join(""),s:[c[0].s,"(?:","-",c[1].s,"(?:","-",c[2].s,"(?:","(?:T| )?",c[3].s,":",c[4].s,"(?::",c[5].s,")?","(?:(?:\\.|,)(\\d+))?","(Z|(?:[-+]\\d{2}(?::)?\\d{2}))?",")?",")?",")?"].join("")}},U:{g:1,c:"u = parseInt(results[{0}], 10);\n",s:"(-?\\d+)"}},dateFormat:function(c,d){return a.format(c,d)},isEqual:function(d,c){if(d&&c){return(d.getTime()===c.getTime())}return !(d||c)},format:function(d,e){var c=a.formatFunctions;if(!Ext.isDate(d)){return""}if(c[e]==null){a.createFormat(e)}return c[e].call(d)+""},getTimezone:function(c){return c.toString().replace(/^.* (?:\((.*)\)|([A-Z]{1,4})(?:[\-+][0-9]{4})?(?: -?\d+)?)$/,"$1$2").replace(/[^A-Z]/g,"")},getGMTOffset:function(c,d){var e=c.getTimezoneOffset();return(e>0?"-":"+")+Ext.String.leftPad(Math.floor(Math.abs(e)/60),2,"0")+(d?":":"")+Ext.String.leftPad(Math.abs(e%60),2,"0")},getDayOfYear:function(g){var e=0,j=Ext.Date.clone(g),c=g.getMonth(),h;for(h=0,j.setDate(1),j.setMonth(0);h<c;j.setMonth(++h)){e+=a.getDaysInMonth(j)}return e+g.getDate()-1},getWeekOfYear:(function(){var c=86400000,d=7*c;return function(g){var h=Date.UTC(g.getFullYear(),g.getMonth(),g.getDate()+3)/c,e=Math.floor(h/7),i=new Date(e*d).getUTCFullYear();return e-Math.floor(Date.UTC(i,0,7)/d)+1}}()),isLeapYear:function(c){var d=c.getFullYear();return !!((d&3)==0&&(d%100||(d%400==0&&d)))},getFirstDayOfMonth:function(d){var c=(d.getDay()-(d.getDate()-1))%7;return(c<0)?(c+7):c},getLastDayOfMonth:function(c){return a.getLastDateOfMonth(c).getDay()},getFirstDateOfMonth:function(c){return new Date(c.getFullYear(),c.getMonth(),1)},getLastDateOfMonth:function(c){return new Date(c.getFullYear(),c.getMonth(),a.getDaysInMonth(c))},getDaysInMonth:(function(){var c=[31,28,31,30,31,30,31,31,30,31,30,31];return function(e){var d=e.getMonth();return d==1&&a.isLeapYear(e)?29:c[d]}}()),getSuffix:function(c){switch(c.getDate()){case 1:case 21:case 31:return"st";case 2:case 22:return"nd";case 3:case 23:return"rd";default:return"th"}},clone:function(c){return new Date(c.getTime())},isDST:function(c){return new Date(c.getFullYear(),0,1).getTimezoneOffset()!=c.getTimezoneOffset()},clearTime:function(e,j){if(j){return Ext.Date.clearTime(Ext.Date.clone(e))}var h=e.getDate(),g,i;e.setHours(0);e.setMinutes(0);e.setSeconds(0);e.setMilliseconds(0);if(e.getDate()!=h){for(g=1,i=a.add(e,Ext.Date.HOUR,g);i.getDate()!=h;g++,i=a.add(e,Ext.Date.HOUR,g)){}e.setDate(h);e.setHours(i.getHours())}return e},add:function(h,g,i){var j=Ext.Date.clone(h),c=Ext.Date,e;if(!g||i===0){return j}switch(g.toLowerCase()){case Ext.Date.MILLI:j.setMilliseconds(j.getMilliseconds()+i);break;case Ext.Date.SECOND:j.setSeconds(j.getSeconds()+i);break;case Ext.Date.MINUTE:j.setMinutes(j.getMinutes()+i);break;case Ext.Date.HOUR:j.setHours(j.getHours()+i);break;case Ext.Date.DAY:j.setDate(j.getDate()+i);break;case Ext.Date.MONTH:e=h.getDate();if(e>28){e=Math.min(e,Ext.Date.getLastDateOfMonth(Ext.Date.add(Ext.Date.getFirstDateOfMonth(h),Ext.Date.MONTH,i)).getDate())}j.setDate(e);j.setMonth(h.getMonth()+i);break;case Ext.Date.YEAR:e=h.getDate();if(e>28){e=Math.min(e,Ext.Date.getLastDateOfMonth(Ext.Date.add(Ext.Date.getFirstDateOfMonth(h),Ext.Date.YEAR,i)).getDate())}j.setDate(e);j.setFullYear(h.getFullYear()+i);break}return j},between:function(d,g,c){var e=d.getTime();return g.getTime()<=e&&e<=c.getTime()},compat:function(){var d=window.Date,c,l,j=["useStrict","formatCodeToRegex","parseFunctions","parseRegexes","formatFunctions","y2kYear","MILLI","SECOND","MINUTE","HOUR","DAY","MONTH","YEAR","defaults","dayNames","monthNames","monthNumbers","getShortMonthName","getShortDayName","getMonthNumber","formatCodes","isValid","parseDate","getFormatCode","createFormat","createParser","parseCodes"],h=["dateFormat","format","getTimezone","getGMTOffset","getDayOfYear","getWeekOfYear","isLeapYear","getFirstDayOfMonth","getLastDayOfMonth","getDaysInMonth","getSuffix","clone","isDST","clearTime","add","between"],i=j.length,e=h.length,g,k,m;for(m=0;m<i;m++){g=j[m];d[g]=a[g]}for(c=0;c<e;c++){k=h[c];d.prototype[k]=function(){var n=Array.prototype.slice.call(arguments);n.unshift(this);return a[k].apply(a,n)}}}};var a=Ext.Date}());(function(a){var c=[],b=function(){};Ext.apply(b,{$className:"Ext.Base",$isClass:true,create:function(){return Ext.create.apply(Ext,[this].concat(Array.prototype.slice.call(arguments,0)))},extend:function(j){var d=j.prototype,m,g,h,k,e,l;g=this.prototype=Ext.Object.chain(d);g.self=this;this.superclass=g.superclass=d;if(!j.$isClass){m=Ext.Base.prototype;for(h in m){if(h in g){g[h]=m[h]}}}l=d.$inheritableStatics;if(l){for(h=0,k=l.length;h<k;h++){e=l[h];if(!this.hasOwnProperty(e)){this[e]=j[e]}}}if(j.$onExtended){this.$onExtended=j.$onExtended.slice()}g.config=new g.configClass();g.initConfigList=g.initConfigList.slice();g.initConfigMap=Ext.clone(g.initConfigMap);g.configMap=Ext.Object.chain(g.configMap)},$onExtended:[],triggerExtended:function(){var g=this.$onExtended,e=g.length,d,h;if(e>0){for(d=0;d<e;d++){h=g[d];h.fn.apply(h.scope||this,arguments)}}},onExtended:function(e,d){this.$onExtended.push({fn:e,scope:d});return this},addConfig:function(h,l){var n=this.prototype,m=Ext.Class.configNameCache,i=n.configMap,j=n.initConfigList,g=n.initConfigMap,k=n.config,d,e,o;for(e in h){if(h.hasOwnProperty(e)){if(!i[e]){i[e]=true}o=h[e];d=m[e].initialized;if(!g[e]&&o!==null&&!n[d]){g[e]=true;j.push(e)}}}if(l){Ext.merge(k,h)}else{Ext.mergeIf(k,h)}n.configClass=Ext.Object.classify(k)},addStatics:function(d){var g,e;for(e in d){if(d.hasOwnProperty(e)){g=d[e];if(typeof g=="function"&&!g.$isClass&&g!==Ext.emptyFn&&g!==Ext.identityFn){g.$owner=this;g.$name=e}this[e]=g}}return this},addInheritableStatics:function(e){var i,d,h=this.prototype,g,j;i=h.$inheritableStatics;d=h.$hasInheritableStatics;if(!i){i=h.$inheritableStatics=[];d=h.$hasInheritableStatics={}}for(g in e){if(e.hasOwnProperty(g)){j=e[g];this[g]=j;if(!d[g]){d[g]=true;i.push(g)}}}return this},addMembers:function(e){var h=this.prototype,d=Ext.enumerables,l=[],j,k,g,m;for(g in e){l.push(g)}if(d){l.push.apply(l,d)}for(j=0,k=l.length;j<k;j++){g=l[j];if(e.hasOwnProperty(g)){m=e[g];if(typeof m=="function"&&!m.$isClass&&m!==Ext.emptyFn){m.$owner=this;m.$name=g}h[g]=m}}return this},addMember:function(d,e){if(typeof e=="function"&&!e.$isClass&&e!==Ext.emptyFn){e.$owner=this;e.$name=d}this.prototype[d]=e;return this},implement:function(){this.addMembers.apply(this,arguments)},borrow:function(j,g){var n=this.prototype,m=j.prototype,h,k,e,l,d;g=Ext.Array.from(g);for(h=0,k=g.length;h<k;h++){e=g[h];d=m[e];if(typeof d=="function"){l=Ext.Function.clone(d);l.$owner=this;l.$name=e;n[e]=l}else{n[e]=d}}return this},override:function(e){var m=this,o=Ext.enumerables,k=m.prototype,h=Ext.Function.clone,d,j,g,n,l,i;if(arguments.length===2){d=e;e={};e[d]=arguments[1];o=null}do{l=[];n=null;for(d in e){if(d=="statics"){n=e[d]}else{if(d=="config"){m.addConfig(e[d],true)}else{l.push(d)}}}if(o){l.push.apply(l,o)}for(j=l.length;j--;){d=l[j];if(e.hasOwnProperty(d)){g=e[d];if(typeof g=="function"&&!g.$className&&g!==Ext.emptyFn){if(typeof g.$owner!="undefined"){g=h(g)}g.$owner=m;g.$name=d;i=k[d];if(i){g.$previous=i}}k[d]=g}}k=m;e=n}while(e);return this},callParent:function(d){var e;return(e=this.callParent.caller)&&(e.$previous||((e=e.$owner?e:e.caller)&&e.$owner.superclass.self[e.$name])).apply(this,d||c)},callSuper:function(d){var e;return(e=this.callSuper.caller)&&((e=e.$owner?e:e.caller)&&e.$owner.superclass.self[e.$name]).apply(this,d||c)},mixin:function(g,i){var d=i.prototype,e=this.prototype,h;if(typeof d.onClassMixedIn!="undefined"){d.onClassMixedIn.call(i,this)}if(!e.hasOwnProperty("mixins")){if("mixins" in e){e.mixins=Ext.Object.chain(e.mixins)}else{e.mixins={}}}for(h in d){if(h==="mixins"){Ext.merge(e.mixins,d[h])}else{if(typeof e[h]=="undefined"&&h!="mixinId"&&h!="config"){e[h]=d[h]}}}if("config" in d){this.addConfig(d.config,false)}e.mixins[g]=d},getName:function(){return Ext.getClassName(this)},createAlias:a(function(e,d){this.override(e,function(){return this[d].apply(this,arguments)})}),addXtype:function(i){var e=this.prototype,h=e.xtypesMap,g=e.xtypes,d=e.xtypesChain;if(!e.hasOwnProperty("xtypesMap")){h=e.xtypesMap=Ext.merge({},e.xtypesMap||{});g=e.xtypes=e.xtypes?[].concat(e.xtypes):[];d=e.xtypesChain=e.xtypesChain?[].concat(e.xtypesChain):[];e.xtype=i}if(!h[i]){h[i]=true;g.push(i);d.push(i);Ext.ClassManager.setAlias(this,"widget."+i)}return this}});b.implement({isInstance:true,$className:"Ext.Base",configClass:Ext.emptyFn,initConfigList:[],configMap:{},initConfigMap:{},statics:function(){var e=this.statics.caller,d=this.self;if(!e){return d}return e.$owner},callParent:function(e){var g,d=(g=this.callParent.caller)&&(g.$previous||((g=g.$owner?g:g.caller)&&g.$owner.superclass[g.$name]));return d.apply(this,e||c)},callSuper:function(e){var g,d=(g=this.callSuper.caller)&&((g=g.$owner?g:g.caller)&&g.$owner.superclass[g.$name]);return d.apply(this,e||c)},self:b,constructor:function(){return this},initConfig:function(g){var m=g,l=Ext.Class.configNameCache,j=new this.configClass(),p=this.initConfigList,h=this.configMap,o,k,n,e,d;this.initConfig=Ext.emptyFn;this.initialConfig=m||{};this.config=g=(m)?Ext.merge(j,g):j;if(m){p=p.slice();for(e in m){if(h[e]){if(m[e]!==null){p.push(e);this[l[e].initialized]=false}}}}for(k=0,n=p.length;k<n;k++){e=p[k];o=l[e];d=o.initialized;if(!this[d]){this[d]=true;this[o.set].call(this,g[e])}}return this},hasConfig:function(d){return Boolean(this.configMap[d])},setConfig:function(h,l){if(!h){return this}var g=Ext.Class.configNameCache,d=this.config,k=this.configMap,j=this.initialConfig,e,i;l=Boolean(l);for(e in h){if(l&&j.hasOwnProperty(e)){continue}i=h[e];d[e]=i;if(k[e]){this[g[e].set](i)}}return this},getConfig:function(e){var d=Ext.Class.configNameCache;return this[d[e].get]()},getInitialConfig:function(e){var d=this.config;if(!e){return d}else{return d[e]}},onConfigUpdate:function(k,m,n){var o=this.self,g,j,d,h,l,e;k=Ext.Array.from(k);n=n||this;for(g=0,j=k.length;g<j;g++){d=k[g];h="update"+Ext.String.capitalize(d);l=this[h]||Ext.emptyFn;e=function(){l.apply(this,arguments);n[m].apply(n,arguments)};e.$name=h;e.$owner=o;this[h]=e}},destroy:function(){this.destroy=Ext.emptyFn}});b.prototype.callOverridden=b.prototype.callParent;Ext.Base=b}(Ext.Function.flexSetter));(function(){var c,b=Ext.Base,g=[],e,d;for(e in b){if(b.hasOwnProperty(e)){g.push(e)}}d=g.length;function a(i){function h(){return this.constructor.apply(this,arguments)||null}return h}Ext.Class=c=function(i,j,h){if(typeof i!="function"){h=j;j=i;i=null}if(!j){j={}}i=c.create(i,j);c.process(i,j,h);return i};Ext.apply(c,{onBeforeCreated:function(i,j,h){i.addMembers(j);h.onCreated.call(i,i)},create:function(h,l){var j,k;if(!h){h=a()}for(k=0;k<d;k++){j=g[k];h[j]=b[j]}return h},process:function(h,q,m){var l=q.preprocessors||c.defaultPreprocessors,t=this.preprocessors,w={onBeforeCreated:this.onBeforeCreated},v=[],x,p,o,u,n,s,r,k;delete q.preprocessors;for(o=0,u=l.length;o<u;o++){x=l[o];if(typeof x=="string"){x=t[x];p=x.properties;if(p===true){v.push(x.fn)}else{if(p){for(n=0,s=p.length;n<s;n++){r=p[n];if(q.hasOwnProperty(r)){v.push(x.fn);break}}}}}else{v.push(x)}}w.onCreated=m?m:Ext.emptyFn;w.preprocessors=v;this.doProcess(h,q,w)},doProcess:function(i,l,h){var k=this,j=h.preprocessors.shift();if(!j){h.onBeforeCreated.apply(k,arguments);return}if(j.call(k,i,l,h,k.doProcess)!==false){k.doProcess(i,l,h)}},preprocessors:{},registerPreprocessor:function(i,l,j,h,k){if(!h){h="last"}if(!j){j=[i]}this.preprocessors[i]={name:i,properties:j||false,fn:l};this.setDefaultPreprocessorPosition(i,h,k);return this},getPreprocessor:function(h){return this.preprocessors[h]},getPreprocessors:function(){return this.preprocessors},defaultPreprocessors:[],getDefaultPreprocessors:function(){return this.defaultPreprocessors},setDefaultPreprocessors:function(h){this.defaultPreprocessors=Ext.Array.from(h);return this},setDefaultPreprocessorPosition:function(j,l,k){var h=this.defaultPreprocessors,i;if(typeof l=="string"){if(l==="first"){h.unshift(j);return this}else{if(l==="last"){h.push(j);return this}}l=(l==="after")?1:-1}i=Ext.Array.indexOf(h,k);if(i!==-1){Ext.Array.splice(h,Math.max(0,i+l),0,j)}return this},configNameCache:{},getConfigNameMap:function(j){var i=this.configNameCache,k=i[j],h;if(!k){h=j.charAt(0).toUpperCase()+j.substr(1);k=i[j]={internal:j,initialized:"_is"+h+"Initialized",apply:"apply"+h,update:"update"+h,set:"set"+h,get:"get"+h,doSet:"doSet"+h,changeEvent:j.toLowerCase()+"change"}}return k}});c.registerPreprocessor("extend",function(j,n){var m=Ext.Base,o=m.prototype,p=n.extend,l,h,k;delete n.extend;if(p&&p!==Object){l=p}else{l=m}h=l.prototype;if(!l.$isClass){for(k in o){if(!h[k]){h[k]=o[k]}}}j.extend(l);j.triggerExtended.apply(j,arguments);if(n.onClassExtended){j.onExtended(n.onClassExtended,j);delete n.onClassExtended}},true);c.registerPreprocessor("statics",function(h,i){h.addStatics(i.statics);delete i.statics});c.registerPreprocessor("inheritableStatics",function(h,i){h.addInheritableStatics(i.inheritableStatics);delete i.inheritableStatics});c.registerPreprocessor("config",function(h,k){var j=k.config,i=h.prototype;delete k.config;Ext.Object.each(j,function(n,w){var u=c.getConfigNameMap(n),q=u.internal,l=u.initialized,v=u.apply,o=u.update,t=u.set,m=u.get,y=(t in i)||k.hasOwnProperty(t),p=(v in i)||k.hasOwnProperty(v),r=(o in i)||k.hasOwnProperty(o),x,s;if(w===null||(!y&&!p&&!r)){i[q]=w;i[l]=true}else{i[l]=false}if(!y){k[t]=function(B){var A=this[q],z=this[v],C=this[o];if(!this[l]){this[l]=true}if(z){B=z.call(this,B,A)}if(typeof B!="undefined"){this[q]=B;if(C&&B!==A){C.call(this,B,A)}}return this}}if(!(m in i)||k.hasOwnProperty(m)){s=k[m]||false;if(s){x=function(){return s.apply(this,arguments)}}else{x=function(){return this[q]}}k[m]=function(){var z;if(!this[l]){this[l]=true;this[t](this.config[n])}z=this[m];if("$previous" in z){z.$previous=x}else{this[m]=x}return x.apply(this,arguments)}}});h.addConfig(j,true)});c.registerPreprocessor("mixins",function(l,p,h){var j=p.mixins,m,k,n,o;delete p.mixins;Ext.Function.interceptBefore(h,"onCreated",function(){if(j instanceof Array){for(n=0,o=j.length;n<o;n++){k=j[n];m=k.prototype.mixinId||k.$className;l.mixin(m,k)}}else{for(var i in j){if(j.hasOwnProperty(i)){l.mixin(i,j[i])}}}})});Ext.extend=function(j,k,i){if(arguments.length===2&&Ext.isObject(k)){i=k;k=j;j=null}var h;if(!k){throw new Error("[Ext.extend] Attempting to extend from a class which has not been loaded on the page.")}i.extend=k;i.preprocessors=["extend","statics","inheritableStatics","mixins","config"];if(j){h=new c(j,i);h.prototype.constructor=j}else{h=new c(i)}h.prototype.override=function(n){for(var l in n){if(n.hasOwnProperty(l)){this[l]=n[l]}}};return h}}());(function(c,e,h,d,g){function a(){function i(){return this.constructor.apply(this,arguments)||null}return i}var b=Ext.ClassManager={classes:{},existCache:{},namespaceRewrites:[{from:"Ext.",to:Ext}],maps:{alternateToName:{},aliasToName:{},nameToAliases:{},nameToAlternates:{}},enableNamespaceParseCache:true,namespaceParseCache:{},instantiators:[],isCreated:function(n){var m=this.existCache,l,o,k,j,p;if(this.classes[n]||m[n]){return true}j=g;p=this.parseNamespace(n);for(l=0,o=p.length;l<o;l++){k=p[l];if(typeof k!="string"){j=k}else{if(!j||!j[k]){return false}j=j[k]}}m[n]=true;this.triggerCreated(n);return true},createdListeners:[],nameCreatedListeners:{},triggerCreated:function(s){var u=this.createdListeners,m=this.nameCreatedListeners,n=this.maps.nameToAlternates[s],t=[s],p,r,o,q,l,k;for(p=0,r=u.length;p<r;p++){l=u[p];l.fn.call(l.scope,s)}if(n){t.push.apply(t,n)}for(p=0,r=t.length;p<r;p++){k=t[p];u=m[k];if(u){for(o=0,q=u.length;o<q;o++){l=u[o];l.fn.call(l.scope,k)}delete m[k]}}},onCreated:function(m,l,k){var j=this.createdListeners,i=this.nameCreatedListeners,n={fn:m,scope:l};if(k){if(this.isCreated(k)){m.call(l,k);return}if(!i[k]){i[k]=[]}i[k].push(n)}else{j.push(n)}},parseNamespace:function(l){var j=this.namespaceParseCache,m,o,q,k,t,s,r,n,p;if(this.enableNamespaceParseCache){if(j.hasOwnProperty(l)){return j[l]}}m=[];o=this.namespaceRewrites;q=g;k=l;for(n=0,p=o.length;n<p;n++){t=o[n];s=t.from;r=t.to;if(k===s||k.substring(0,s.length)===s){k=k.substring(s.length);if(typeof r!="string"){q=r}else{m=m.concat(r.split("."))}break}}m.push(q);m=m.concat(k.split("."));if(this.enableNamespaceParseCache){j[l]=m}return m},setNamespace:function(m,p){var k=g,q=this.parseNamespace(m),o=q.length-1,j=q[o],n,l;for(n=0;n<o;n++){l=q[n];if(typeof l!="string"){k=l}else{if(!k[l]){k[l]={}}k=k[l]}}k[j]=p;return k[j]},createNamespaces:function(){var k=g,p,m,n,l,o,q;for(n=0,o=arguments.length;n<o;n++){p=this.parseNamespace(arguments[n]);for(l=0,q=p.length;l<q;l++){m=p[l];if(typeof m!="string"){k=m}else{if(!k[m]){k[m]={}}k=k[m]}}}return k},set:function(i,m){var l=this,o=l.maps,n=o.nameToAlternates,k=l.getName(m),j;l.classes[i]=l.setNamespace(i,m);if(k&&k!==i){o.alternateToName[i]=k;j=n[k]||(n[k]=[]);j.push(i)}return this},get:function(l){var n=this.classes,j,p,k,m,o;if(n[l]){return n[l]}j=g;p=this.parseNamespace(l);for(m=0,o=p.length;m<o;m++){k=p[m];if(typeof k!="string"){j=k}else{if(!j||!j[k]){return null}j=j[k]}}return j},setAlias:function(i,j){var l=this.maps.aliasToName,m=this.maps.nameToAliases,k;if(typeof i=="string"){k=i}else{k=this.getName(i)}if(j&&l[j]!==k){l[j]=k}if(!m[k]){m[k]=[]}if(j){Ext.Array.include(m[k],j)}return this},addNameAliasMappings:function(j){var o=this.maps.aliasToName,p=this.maps.nameToAliases,m,n,l,k;for(m in j){n=p[m]||(p[m]=[]);for(k=0;k<j[m].length;k++){l=j[m][k];if(!o[l]){o[l]=m;n.push(l)}}}return this},addNameAlternateMappings:function(m){var j=this.maps.alternateToName,p=this.maps.nameToAlternates,l,n,o,k;for(l in m){n=p[l]||(p[l]=[]);for(k=0;k<m[l].length;k++){o=m[l];if(!j[o]){j[o]=l;n.push(o)}}}return this},getByAlias:function(i){return this.get(this.getNameByAlias(i))},getNameByAlias:function(i){return this.maps.aliasToName[i]||""},getNameByAlternate:function(i){return this.maps.alternateToName[i]||""},getAliasesByName:function(i){return this.maps.nameToAliases[i]||[]},getName:function(i){return i&&i.$className||""},getClass:function(i){return i&&i.self||null},create:function(j,l,i){var k=a();if(typeof l=="function"){l=l(k)}l.$className=j;return new c(k,l,function(){var m=l.postprocessors||b.defaultPostprocessors,t=b.postprocessors,u=[],s,o,r,n,q,p,v;delete l.postprocessors;for(o=0,r=m.length;o<r;o++){s=m[o];if(typeof s=="string"){s=t[s];p=s.properties;if(p===true){u.push(s.fn)}else{if(p){for(n=0,q=p.length;n<q;n++){v=p[n];if(l.hasOwnProperty(v)){u.push(s.fn);break}}}}}else{u.push(s)}}l.postprocessors=u;l.createdFn=i;b.processCreate(j,this,l)})},processCreate:function(l,j,n){var m=this,i=n.postprocessors.shift(),k=n.createdFn;if(!i){if(l){m.set(l,j)}if(k){k.call(j,j)}if(l){m.triggerCreated(l)}return}if(i.call(m,l,j,n,m.processCreate)!==false){m.processCreate(l,j,n)}},createOverride:function(l,p,j){var o=this,n=p.override,k=p.requires,i=p.uses,m=function(){var q,r;if(k){r=k;k=null;Ext.Loader.require(r,m)}else{q=o.get(n);delete p.override;delete p.requires;delete p.uses;Ext.override(q,p);o.triggerCreated(l);if(i){Ext.Loader.addUsedClasses(i)}if(j){j.call(q)}}};o.existCache[l]=true;o.onCreated(m,o,n);return o},instantiateByAlias:function(){var j=arguments[0],i=h.call(arguments),k=this.getNameByAlias(j);if(!k){k=this.maps.aliasToName[j];Ext.syncRequire(k)}i[0]=k;return this.instantiate.apply(this,i)},instantiate:function(){var k=arguments[0],m=typeof k,j=h.call(arguments,1),l=k,n,i;if(m!="function"){if(m!="string"&&j.length===0){j=[k];k=k.xclass}i=this.get(k)}else{i=k}if(!i){n=this.getNameByAlias(k);if(n){k=n;i=this.get(k)}}if(!i){n=this.getNameByAlternate(k);if(n){k=n;i=this.get(k)}}if(!i){Ext.syncRequire(k);i=this.get(k)}return this.getInstantiator(j.length)(i,j)},dynInstantiate:function(j,i){i=d(i,true);i.unshift(j);return this.instantiate.apply(this,i)},getInstantiator:function(m){var l=this.instantiators,n,k,j;n=l[m];if(!n){k=m;j=[];for(k=0;k<m;k++){j.push("a["+k+"]")}n=l[m]=new Function("c","a","return new c("+j.join(",")+")")}return n},postprocessors:{},defaultPostprocessors:[],registerPostprocessor:function(j,m,k,i,l){if(!i){i="last"}if(!k){k=[j]}this.postprocessors[j]={name:j,properties:k||false,fn:m};this.setDefaultPostprocessorPosition(j,i,l);return this},setDefaultPostprocessors:function(i){this.defaultPostprocessors=d(i);return this},setDefaultPostprocessorPosition:function(j,m,l){var k=this.defaultPostprocessors,i;if(typeof m=="string"){if(m==="first"){k.unshift(j);return this}else{if(m==="last"){k.push(j);return this}}m=(m==="after")?1:-1}i=Ext.Array.indexOf(k,l);if(i!==-1){Ext.Array.splice(k,Math.max(0,i+m),0,j)}return this},getNamesByExpression:function(q){var o=this.maps.nameToAliases,r=[],j,n,l,k,s,m,p;if(q.indexOf("*")!==-1){q=q.replace(/\*/g,"(.*?)");s=new RegExp("^"+q+"$");for(j in o){if(o.hasOwnProperty(j)){l=o[j];if(j.search(s)!==-1){r.push(j)}else{for(m=0,p=l.length;m<p;m++){n=l[m];if(n.search(s)!==-1){r.push(j);break}}}}}}else{k=this.getNameByAlias(q);if(k){r.push(k)}else{k=this.getNameByAlternate(q);if(k){r.push(k)}else{r.push(q)}}}return r}};b.registerPostprocessor("alias",function(l,k,o){var j=o.alias,m,n;for(m=0,n=j.length;m<n;m++){e=j[m];this.setAlias(k,e)}},["xtype","alias"]);b.registerPostprocessor("singleton",function(j,i,l,k){k.call(this,j,new i(),l);return false});b.registerPostprocessor("alternateClassName",function(k,j,o){var m=o.alternateClassName,l,n,p;if(!(m instanceof Array)){m=[m]}for(l=0,n=m.length;l<n;l++){p=m[l];this.set(p,j)}});Ext.apply(Ext,{create:e(b,"instantiate"),widget:function(k,j){var o=k,l,m,i,n;if(typeof o!="string"){j=k;o=j.xtype}else{j=j||{}}if(j.isComponent){return j}l="widget."+o;m=b.getNameByAlias(l);if(!m){n=true}i=b.get(m);if(n||!i){return b.instantiateByAlias(l,j)}return new i(j)},createByAlias:e(b,"instantiateByAlias"),define:function(j,k,i){if(k.override){return b.createOverride.apply(b,arguments)}return b.create.apply(b,arguments)},getClassName:e(b,"getName"),getDisplayName:function(i){if(i){if(i.displayName){return i.displayName}if(i.$name&&i.$class){return Ext.getClassName(i.$class)+"#"+i.$name}if(i.$className){return i.$className}}return"Anonymous"},getClass:e(b,"getClass"),namespace:e(b,"createNamespaces")});Ext.createWidget=Ext.widget;Ext.ns=Ext.namespace;c.registerPreprocessor("className",function(i,j){if(j.$className){i.$className=j.$className}},true,"first");c.registerPreprocessor("alias",function(u,o){var s=u.prototype,l=d(o.xtype),j=d(o.alias),v="widget.",t=v.length,p=Array.prototype.slice.call(s.xtypesChain||[]),m=Ext.merge({},s.xtypesMap||{}),n,r,q,k;for(n=0,r=j.length;n<r;n++){q=j[n];if(q.substring(0,t)===v){k=q.substring(t);Ext.Array.include(l,k)}}u.xtype=o.xtype=l[0];o.xtypes=l;for(n=0,r=l.length;n<r;n++){k=l[n];if(!m[k]){m[k]=true;p.push(k)}}o.xtypesChain=p;o.xtypesMap=m;Ext.Function.interceptAfter(o,"onClassCreated",function(){var i=s.mixins,x,w;for(x in i){if(i.hasOwnProperty(x)){w=i[x];l=w.xtypes;if(l){for(n=0,r=l.length;n<r;n++){k=l[n];if(!m[k]){m[k]=true;p.push(k)}}}}}});for(n=0,r=l.length;n<r;n++){k=l[n];Ext.Array.include(j,v+k)}o.alias=j},["xtype","alias"])}(Ext.Class,Ext.Function.alias,Array.prototype.slice,Ext.Array.from,Ext.global));Ext.Loader=new function(){var j=this,b=Ext.ClassManager,r=Ext.Class,e=Ext.Function.flexSetter,m=Ext.Function.alias,a=Ext.Function.pass,d=Ext.Function.defer,h=Ext.Array.erase,l=["extend","mixins","requires"],t={},k=[],c=/\/\.\//g,g=/\./g;Ext.apply(j,{isInHistory:t,history:k,config:{enabled:false,scriptChainDelay:false,disableCaching:true,disableCachingParam:"_dc",garbageCollect:false,paths:{Ext:"."},preserveScripts:true,scriptCharset:undefined},setConfig:function(w,x){if(Ext.isObject(w)&&arguments.length===1){Ext.merge(j.config,w)}else{j.config[w]=(Ext.isObject(x))?Ext.merge(j.config[w],x):x}return j},getConfig:function(w){if(w){return j.config[w]}return j.config},setPath:e(function(w,x){j.config.paths[w]=x;return j}),addClassPathMappings:function(x){var w;for(w in x){j.config.paths[w]=x[w]}return j},getPath:function(w){var y="",z=j.config.paths,x=j.getPrefix(w);if(x.length>0){if(x===w){return z[x]}y=z[x];w=w.substring(x.length+1)}if(y.length>0){y+="/"}return y.replace(c,"/")+w.replace(g,"/")+".js"},getPrefix:function(x){var z=j.config.paths,y,w="";if(z.hasOwnProperty(x)){return x}for(y in z){if(z.hasOwnProperty(y)&&y+"."===x.substring(0,y.length+1)){if(y.length>w.length){w=y}}}return w},isAClassNameWithAKnownPrefix:function(w){var x=j.getPrefix(w);return x!==""&&x!==w},require:function(y,x,w,z){if(x){x.call(w)}},syncRequire:function(){},exclude:function(w){return{require:function(z,y,x){return j.require(z,y,x,w)},syncRequire:function(z,y,x){return j.syncRequire(z,y,x,w)}}},onReady:function(z,y,A,w){var x;if(A!==false&&Ext.onDocumentReady){x=z;z=function(){Ext.onDocumentReady(x,y,w)}}z.call(y)}});var o=[],p={},s={},q={},n={},u=[],v=[],i={};Ext.apply(j,{documentHead:typeof document!="undefined"&&(document.head||document.getElementsByTagName("head")[0]),isLoading:false,queue:o,isClassFileLoaded:p,isFileLoaded:s,readyListeners:u,optionalRequires:v,requiresMap:i,numPendingFiles:0,numLoadedFiles:0,hasFileLoadError:false,classNameToFilePathMap:q,scriptsLoading:0,syncModeEnabled:false,scriptElements:n,refreshQueue:function(){var A=o.length,x,z,w,y;if(!A&&!j.scriptsLoading){return j.triggerReady()}for(x=0;x<A;x++){z=o[x];if(z){y=z.requires;if(y.length>j.numLoadedFiles){continue}for(w=0;w<y.length;){if(b.isCreated(y[w])){h(y,w,1)}else{w++}}if(z.requires.length===0){h(o,x,1);z.callback.call(z.scope);j.refreshQueue();break}}}return j},injectScriptElement:function(w,D,A,F,y){var E=document.createElement("script"),B=false,x=j.config,C=function(){if(!B){B=true;E.onload=E.onreadystatechange=E.onerror=null;if(typeof x.scriptChainDelay=="number"){d(D,x.scriptChainDelay,F)}else{D.call(F)}j.cleanupScriptElement(E,x.preserveScripts===false,x.garbageCollect)}},z=function(G){d(A,1,F);j.cleanupScriptElement(E,x.preserveScripts===false,x.garbageCollect)};E.type="text/javascript";E.onerror=z;y=y||x.scriptCharset;if(y){E.charset=y}if("addEventListener" in E){E.onload=C}else{if("readyState" in E){E.onreadystatechange=function(){if(this.readyState=="loaded"||this.readyState=="complete"){C()}}}else{E.onload=C}}E.src=w;(j.documentHead||document.getElementsByTagName("head")[0]).appendChild(E);return E},removeScriptElement:function(w){if(n[w]){j.cleanupScriptElement(n[w],true,!!j.getConfig("garbageCollect"));delete n[w]}return j},cleanupScriptElement:function(y,x,z){var A;y.onload=y.onreadystatechange=y.onerror=null;if(x){Ext.removeNode(y);if(z){for(A in y){try{y[A]=null;delete y[A]}catch(w){}}}}return j},loadScript:function(F){var z=j.getConfig(),y=typeof F=="string",x=y?F:F.url,B=!y&&F.onError,C=!y&&F.onLoad,E=!y&&F.scope,D=function(){j.numPendingFiles--;j.scriptsLoading--;if(B){B.call(E,"Failed loading '"+x+"', please verify that the file exists")}if(j.numPendingFiles+j.scriptsLoading===0){j.refreshQueue()}},A=function(){j.numPendingFiles--;j.scriptsLoading--;if(C){C.call(E)}if(j.numPendingFiles+j.scriptsLoading===0){j.refreshQueue()}},w;j.isLoading=true;j.numPendingFiles++;j.scriptsLoading++;w=z.disableCaching?(x+"?"+z.disableCachingParam+"="+Ext.Date.now()):x;n[x]=j.injectScriptElement(w,A,D)},loadScriptFile:function(x,E,C,H,w){if(s[x]){return j}var z=j.getConfig(),I=x+(z.disableCaching?("?"+z.disableCachingParam+"="+Ext.Date.now()):""),y=false,G,A,F,B="";H=H||j;j.isLoading=true;if(!w){F=function(){};n[x]=j.injectScriptElement(I,E,F,H)}else{if(typeof XMLHttpRequest!="undefined"){G=new XMLHttpRequest()}else{G=new ActiveXObject("Microsoft.XMLHTTP")}try{G.open("GET",I,false);G.send(null)}catch(D){y=true}A=(G.status===1223)?204:(G.status===0&&(self.location||{}).protocol=="file:")?200:G.status;y=y||(A===0);if(y){}else{if((A>=200&&A<300)||(A===304)){if(!Ext.isIE){B="\n//@ sourceURL="+x}Ext.globalEval(G.responseText+B);E.call(H)}else{}}G=null}},syncRequire:function(){var w=j.syncModeEnabled;if(!w){j.syncModeEnabled=true}j.require.apply(j,arguments);if(!w){j.syncModeEnabled=false}j.refreshQueue()},require:function(O,F,z,B){var H={},y={},E=[],Q=[],N=[],x=[],D,P,J,I,w,C,M,L,K,G,A;if(B){B=(typeof B==="string")?[B]:B;for(L=0,G=B.length;L<G;L++){w=B[L];if(typeof w=="string"&&w.length>0){E=b.getNamesByExpression(w);for(K=0,A=E.length;K<A;K++){H[E[K]]=true}}}}O=(typeof O==="string")?[O]:(O?O:[]);if(F){if(F.length>0){D=function(){var S=[],R,T;for(R=0,T=x.length;R<T;R++){S.push(b.get(x[R]))}return F.apply(this,S)}}else{D=F}}else{D=Ext.emptyFn}z=z||Ext.global;for(L=0,G=O.length;L<G;L++){I=O[L];if(typeof I=="string"&&I.length>0){Q=b.getNamesByExpression(I);A=Q.length;for(K=0;K<A;K++){M=Q[K];if(H[M]!==true){x.push(M);if(!b.isCreated(M)&&!y[M]){y[M]=true;N.push(M)}}}}}if(N.length>0){if(!j.config.enabled){throw new Error("Ext.Loader is not enabled, so dependencies cannot be resolved dynamically. Missing required class"+((N.length>1)?"es":"")+": "+N.join(", "))}}else{D.call(z);return j}P=j.syncModeEnabled;if(!P){o.push({requires:N.slice(),callback:D,scope:z})}G=N.length;for(L=0;L<G;L++){C=N[L];J=j.getPath(C);if(P&&p.hasOwnProperty(C)){j.numPendingFiles--;j.removeScriptElement(J);delete p[C]}if(!p.hasOwnProperty(C)){p[C]=false;q[C]=J;j.numPendingFiles++;j.loadScriptFile(J,a(j.onFileLoaded,[C,J],j),a(j.onFileLoadError,[C,J],j),j,P)}}if(P){D.call(z);if(G===1){return b.get(C)}}return j},onFileLoaded:function(x,w){j.numLoadedFiles++;p[x]=true;s[w]=true;j.numPendingFiles--;if(j.numPendingFiles===0){j.refreshQueue()}},onFileLoadError:function(y,x,w,z){j.numPendingFiles--;j.hasFileLoadError=true},addUsedClasses:function(y){var w,x,z;if(y){y=(typeof y=="string")?[y]:y;for(x=0,z=y.length;x<z;x++){w=y[x];if(typeof w=="string"&&!Ext.Array.contains(v,w)){v.push(w)}}}return j},triggerReady:function(){var x,w,y=v;if(j.isLoading){j.isLoading=false;if(y.length!==0){y=y.slice();v.length=0;j.require(y,j.triggerReady,j);return j}}while(u.length&&!j.isLoading){x=u.shift();x.fn.call(x.scope)}return j},onReady:function(z,y,A,w){var x;if(A!==false&&Ext.onDocumentReady){x=z;z=function(){Ext.onDocumentReady(x,y,w)}}if(!j.isLoading){z.call(y)}else{u.push({fn:z,scope:y})}},historyPush:function(w){if(w&&p.hasOwnProperty(w)&&!t[w]){t[w]=true;k.push(w)}return j}});Ext.disableCacheBuster=function(x,y){var w=new Date();w.setTime(w.getTime()+(x?10*365:-1)*24*60*60*1000);w=w.toGMTString();document.cookie="ext-cache=1; expires="+w+"; path="+(y||"/")};Ext.require=m(j,"require");Ext.syncRequire=m(j,"syncRequire");Ext.exclude=m(j,"exclude");Ext.onReady=function(y,x,w){j.onReady(y,x,true,w)};r.registerPreprocessor("loader",function(M,A,L,K){var H=this,F=[],w,G=b.getName(M),z,y,E,D,J,C,x,I,B;for(z=0,E=l.length;z<E;z++){C=l[z];if(A.hasOwnProperty(C)){x=A[C];if(typeof x=="string"){F.push(x)}else{if(x instanceof Array){for(y=0,D=x.length;y<D;y++){J=x[y];if(typeof J=="string"){F.push(J)}}}else{if(typeof x!="function"){for(y in x){if(x.hasOwnProperty(y)){J=x[y];if(typeof J=="string"){F.push(J)}}}}}}}}if(F.length===0){return}j.require(F,function(){for(z=0,E=l.length;z<E;z++){C=l[z];if(A.hasOwnProperty(C)){x=A[C];if(typeof x=="string"){A[C]=b.get(x)}else{if(x instanceof Array){for(y=0,D=x.length;y<D;y++){J=x[y];if(typeof J=="string"){A[C][y]=b.get(J)}}}else{if(typeof x!="function"){for(var N in x){if(x.hasOwnProperty(N)){J=x[N];if(typeof J=="string"){A[C][N]=b.get(J)}}}}}}}}K.call(H,M,A,L)});return false},true,"after","className");b.registerPostprocessor("uses",function(y,x,z){var w=z.uses;if(w){j.addUsedClasses(w)}});b.onCreated(j.historyPush)};if(Ext._classPathMetadata){Ext.Loader.addClassPathMappings(Ext._classPathMetadata);Ext._classPathMetadata=null}(function(){var a=document.getElementsByTagName("script"),b=a[a.length-1],d=b.src,c=d.substring(0,d.lastIndexOf("/")+1),e=Ext.Loader;e.setConfig({enabled:true,disableCaching:true,paths:{Ext:c+"src"}})})();Ext._endTime=new Date().getTime();if(Ext._beforereadyhandler){Ext._beforereadyhandler()}Ext.Error=Ext.extend(Error,{statics:{ignore:false,raise:function(a){a=a||{};if(Ext.isString(a)){a={msg:a}}var c=this.raise.caller,b;if(c){if(c.$name){a.sourceMethod=c.$name}if(c.$owner){a.sourceClass=c.$owner.$className}}if(Ext.Error.handle(a)!==true){b=Ext.Error.prototype.toString.call(a);Ext.log({msg:b,level:"error",dump:a,stack:true});throw new Ext.Error(a)}},handle:function(){return Ext.Error.ignore}},name:"Ext.Error",constructor:function(a){if(Ext.isString(a)){a={msg:a}}var b=this;Ext.apply(b,a);b.message=b.message||b.msg},toString:function(){var c=this,b=c.sourceClass?c.sourceClass:"",a=c.sourceMethod?"."+c.sourceMethod+"(): ":"",d=c.msg||"(No description provided)";return b+a+d}});Ext.deprecated=function(a){return Ext.emptyFn};Ext.JSON=(new (function(){var me=this,encodingFunction,decodingFunction,useNative=null,useHasOwn=!!{}.hasOwnProperty,isNative=function(){if(useNative===null){useNative=Ext.USE_NATIVE_JSON&&window.JSON&&JSON.toString()=="[object JSON]"}return useNative},pad=function(n){return n<10?"0"+n:n},doDecode=function(json){return eval("("+json+")")},doEncode=function(o,newline){if(o===null||o===undefined){return"null"}else{if(Ext.isDate(o)){return Ext.JSON.encodeDate(o)}else{if(Ext.isString(o)){return Ext.JSON.encodeString(o)}else{if(typeof o=="number"){return isFinite(o)?String(o):"null"}else{if(Ext.isBoolean(o)){return String(o)}else{if(o.toJSON){return o.toJSON()}else{if(Ext.isArray(o)){return encodeArray(o,newline)}else{if(Ext.isObject(o)){return encodeObject(o,newline)}else{if(typeof o==="function"){return"null"}}}}}}}}}return"undefined"},m={"\b":"\\b","\t":"\\t","\n":"\\n","\f":"\\f","\r":"\\r",'"':'\\"',"\\":"\\\\","\x0b":"\\u000b"},charToReplace=/[\\\"\x00-\x1f\x7f-\uffff]/g,encodeString=function(s){return'"'+s.replace(charToReplace,function(a){var c=m[a];return typeof c==="string"?c:"\\u"+("0000"+a.charCodeAt(0).toString(16)).slice(-4)})+'"'},encodeArray=function(o,newline){var a=["[",""],len=o.length,i;for(i=0;i<len;i+=1){a.push(Ext.JSON.encodeValue(o[i]),",")}a[a.length-1]="]";return a.join("")},encodeObject=function(o,newline){var a=["{",""],i;for(i in o){if(!useHasOwn||o.hasOwnProperty(i)){a.push(Ext.JSON.encodeValue(i),":",Ext.JSON.encodeValue(o[i]),",")}}a[a.length-1]="}";return a.join("")};me.encodeString=encodeString;me.encodeValue=doEncode;me.encodeDate=function(o){return'"'+o.getFullYear()+"-"+pad(o.getMonth()+1)+"-"+pad(o.getDate())+"T"+pad(o.getHours())+":"+pad(o.getMinutes())+":"+pad(o.getSeconds())+'"'};me.encode=function(o){if(!encodingFunction){encodingFunction=isNative()?JSON.stringify:me.encodeValue}return encodingFunction(o)};me.decode=function(json,safe){if(!decodingFunction){decodingFunction=isNative()?JSON.parse:doDecode}try{return decodingFunction(json)}catch(e){if(safe===true){return null}Ext.Error.raise({sourceClass:"Ext.JSON",sourceMethod:"decode",msg:"You're trying to decode an invalid JSON String: "+json})}}})());Ext.encode=Ext.JSON.encode;Ext.decode=Ext.JSON.decode;Ext.apply(Ext,{userAgent:navigator.userAgent.toLowerCase(),cache:{},idSeed:1000,windowId:"ext-window",documentId:"ext-document",isReady:false,enableGarbageCollector:true,enableListenerCollection:true,addCacheEntry:function(e,b,d){d=d||b.dom;var a=e||(b&&b.id)||d.id,c=Ext.cache[a]||(Ext.cache[a]={data:{},events:{},dom:d,skipGarbageCollection:!!(d.getElementById||d.navigator)});if(b){b.$cache=c;c.el=b}return c},updateCacheEntry:function(a,b){a.dom=b;if(a.el){a.el.dom=b}return a},id:function(a,c){var b=this,d="";a=Ext.getDom(a,true)||{};if(a===document){a.id=b.documentId}else{if(a===window){a.id=b.windowId}}if(!a.id){if(b.isSandboxed){d=Ext.sandboxName.toLowerCase()+"-"}a.id=d+(c||"ext-gen")+(++Ext.idSeed)}return a.id},escapeId:(function(){var c=/^[a-zA-Z_][a-zA-Z0-9_\-]*$/i,d=/([\W]{1})/g,b=/^(\d)/g,a=function(h,g){return"\\"+g},e=function(h,g){return"\\00"+g.charCodeAt(0).toString(16)+" "};return function(g){return c.test(g)?g:g.replace(d,a).replace(b,e)}}()),getBody:(function(){var a;return function(){return a||(a=Ext.get(document.body))}}()),getHead:(function(){var a;return function(){return a||(a=Ext.get(document.getElementsByTagName("head")[0]))}}()),getDoc:(function(){var a;return function(){return a||(a=Ext.get(document))}}()),getCmp:function(a){return Ext.ComponentManager.get(a)},getOrientation:function(){return window.innerHeight>window.innerWidth?"portrait":"landscape"},destroy:function(){var c=arguments.length,b,a;for(b=0;b<c;b++){a=arguments[b];if(a){if(Ext.isArray(a)){this.destroy.apply(this,a)}else{if(Ext.isFunction(a.destroy)){a.destroy()}else{if(a.dom){a.remove()}}}}}},callback:function(d,c,b,a){if(Ext.isFunction(d)){b=b||[];c=c||window;if(a){Ext.defer(d,a,c,b)}else{d.apply(c,b)}}},htmlEncode:function(a){return Ext.String.htmlEncode(a)},htmlDecode:function(a){return Ext.String.htmlDecode(a)},urlAppend:function(a,b){return Ext.String.urlAppend(a,b)}});Ext.ns=Ext.namespace;window.undefined=window.undefined;(function(){var o=function(e){return e.test(Ext.userAgent)},t=document.compatMode=="CSS1Compat",F=function(R,Q){var e;return(R&&(e=Q.exec(Ext.userAgent)))?parseFloat(e[1]):0},p=document.documentMode,a=o(/opera/),v=a&&o(/version\/10\.5/),K=o(/\bchrome\b/),z=o(/webkit/),c=!K&&o(/safari/),I=c&&o(/applewebkit\/4/),G=c&&o(/version\/3/),D=c&&o(/version\/4/),j=c&&o(/version\/5\.0/),C=c&&o(/version\/5/),i=!a&&o(/msie/),J=i&&((o(/msie 7/)&&p!=8&&p!=9)||p==7),H=i&&((o(/msie 8/)&&p!=7&&p!=9)||p==8),E=i&&((o(/msie 9/)&&p!=7&&p!=8)||p==9),M=i&&o(/msie 6/),b=!z&&o(/gecko/),P=b&&o(/rv:1\.9/),O=b&&o(/rv:2\.0/),N=b&&o(/rv:5\./),r=b&&o(/rv:10\./),y=P&&o(/rv:1\.9\.0/),w=P&&o(/rv:1\.9\.1/),u=P&&o(/rv:1\.9\.2/),g=o(/windows|win32/),B=o(/macintosh|mac os x/),x=o(/linux/),l=null,m=F(true,/\bchrome\/(\d+\.\d+)/),h=F(true,/\bfirefox\/(\d+\.\d+)/),n=F(i,/msie (\d+\.\d+)/),s=F(a,/version\/(\d+\.\d+)/),d=F(c,/version\/(\d+\.\d+)/),A=F(z,/webkit\/(\d+\.\d+)/),q=/^https/i.test(window.location.protocol),k;try{document.execCommand("BackgroundImageCache",false,true)}catch(L){}k=function(){};k.info=k.warn=k.error=Ext.emptyFn;Ext.setVersion("extjs","4.1.1.1");Ext.apply(Ext,{SSL_SECURE_URL:q&&i?"javascript:''":"about:blank",scopeResetCSS:Ext.buildSettings.scopeResetCSS,resetCls:Ext.buildSettings.baseCSSPrefix+"reset",enableNestedListenerRemoval:false,USE_NATIVE_JSON:false,getDom:function(R,Q){if(!R||!document){return null}if(R.dom){return R.dom}else{if(typeof R=="string"){var S=Ext.getElementById(R);if(S&&i&&Q){if(R==S.getAttribute("id")){return S}else{return null}}return S}else{return R}}},removeNode:M||J||H?(function(){var e;return function(S){if(S&&S.tagName.toUpperCase()!="BODY"){(Ext.enableNestedListenerRemoval)?Ext.EventManager.purgeElement(S):Ext.EventManager.removeAll(S);var Q=Ext.cache,R=S.id;if(Q[R]){delete Q[R].dom;delete Q[R]}if(H&&S.parentNode){S.parentNode.removeChild(S)}e=e||document.createElement("div");e.appendChild(S);e.innerHTML=""}}}()):function(R){if(R&&R.parentNode&&R.tagName.toUpperCase()!="BODY"){(Ext.enableNestedListenerRemoval)?Ext.EventManager.purgeElement(R):Ext.EventManager.removeAll(R);var e=Ext.cache,Q=R.id;if(e[Q]){delete e[Q].dom;delete e[Q]}R.parentNode.removeChild(R)}},isStrict:t,isIEQuirks:i&&!t,isOpera:a,isOpera10_5:v,isWebKit:z,isChrome:K,isSafari:c,isSafari3:G,isSafari4:D,isSafari5:C,isSafari5_0:j,isSafari2:I,isIE:i,isIE6:M,isIE7:J,isIE8:H,isIE9:E,isGecko:b,isGecko3:P,isGecko4:O,isGecko5:N,isGecko10:r,isFF3_0:y,isFF3_5:w,isFF3_6:u,isFF4:4<=h&&h<5,isFF5:5<=h&&h<6,isFF10:10<=h&&h<11,isLinux:x,isWindows:g,isMac:B,chromeVersion:m,firefoxVersion:h,ieVersion:n,operaVersion:s,safariVersion:d,webKitVersion:A,isSecure:q,BLANK_IMAGE_URL:(M||J)?"//www.sencha.com/s.gif":"data:image/gif;base64,R0lGODlhAQABAID/AMDAwAAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==",value:function(R,e,Q){return Ext.isEmpty(R,Q)?e:R},escapeRe:function(e){return e.replace(/([-.*+?\^${}()|\[\]\/\\])/g,"\\$1")},addBehaviors:function(T){if(!Ext.isReady){Ext.onReady(function(){Ext.addBehaviors(T)})}else{var Q={},S,e,R;for(e in T){if((S=e.split("@"))[1]){R=S[0];if(!Q[R]){Q[R]=Ext.select(R)}Q[R].on(S[1],T[e])}}Q=null}},getScrollbarSize:function(Q){if(!Ext.isReady){return{}}if(Q||!l){var e=document.body,R=document.createElement("div");R.style.width=R.style.height="100px";R.style.overflow="scroll";R.style.position="absolute";e.appendChild(R);l={width:R.offsetWidth-R.clientWidth,height:R.offsetHeight-R.clientHeight};e.removeChild(R)}return l},getScrollBarWidth:function(Q){var e=Ext.getScrollbarSize(Q);return e.width+2},copyTo:function(Q,S,U,T){if(typeof U=="string"){U=U.split(/[,;\s]/)}var V,R=U.length,e;for(V=0;V<R;V++){e=U[V];if(T||S.hasOwnProperty(e)){Q[e]=S[e]}}return Q},destroyMembers:function(S){for(var R=1,Q=arguments,e=Q.length;R<e;R++){Ext.destroy(S[Q[R]]);delete S[Q[R]]}},log:k,partition:function(e,T){var U=[[],[]],Q,S,R=e.length;for(Q=0;Q<R;Q++){S=e[Q];U[(T&&T(S,Q,e))||(!T&&S)?0:1].push(S)}return U},invoke:function(e,T){var V=[],U=Array.prototype.slice.call(arguments,2),Q,S,R=e.length;for(Q=0;Q<R;Q++){S=e[Q];if(S&&typeof S[T]=="function"){V.push(S[T].apply(S,U))}else{V.push(undefined)}}return V},zip:function(){var W=Ext.partition(arguments,function(X){return typeof X!="function"}),T=W[0],V=W[1][0],e=Ext.max(Ext.pluck(T,"length")),S=[],U,R,Q;for(U=0;U<e;U++){S[U]=[];if(V){S[U]=V.apply(V,Ext.pluck(T,U))}else{for(R=0,Q=T.length;R<Q;R++){S[U].push(T[R][U])}}}return S},toSentence:function(Q,e){var T=Q.length,S,R;if(T<=1){return Q[0]}else{S=Q.slice(0,T-1);R=Q[T-1];return Ext.util.Format.format("{0} {1} {2}",S.join(", "),e||"and",R)}},useShims:M})}());Ext.application=function(a){Ext.require("Ext.app.Application");Ext.onReady(function(){new Ext.app.Application(a)})};(function(){Ext.ns("Ext.util");Ext.util.Format={};var g=Ext.util.Format,e=/<\/?[^>]+>/gi,c=/(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)/ig,b=/\r?\n/g,d=/[^\d\.]/g,a;Ext.apply(g,{thousandSeparator:",",decimalSeparator:".",currencyPrecision:2,currencySign:"$",currencyAtEnd:false,undef:function(h){return h!==undefined?h:""},defaultValue:function(i,h){return i!==undefined&&i!==""?i:h},substr:"ab".substr(-1)!="b"?function(i,k,h){var j=String(i);return(k<0)?j.substr(Math.max(j.length+k,0),h):j.substr(k,h)}:function(i,j,h){return String(i).substr(j,h)},lowercase:function(h){return String(h).toLowerCase()},uppercase:function(h){return String(h).toUpperCase()},usMoney:function(h){return g.currency(h,"$",2)},currency:function(k,m,j,h){var o="",n=",0",l=0;k=k-0;if(k<0){k=-k;o="-"}j=Ext.isDefined(j)?j:g.currencyPrecision;n+=n+(j>0?".":"");for(;l<j;l++){n+="0"}k=g.number(k,n);if((h||g.currencyAtEnd)===true){return Ext.String.format("{0}{1}{2}",o,k,m||g.currencySign)}else{return Ext.String.format("{0}{1}{2}",o,m||g.currencySign,k)}},date:function(h,i){if(!h){return""}if(!Ext.isDate(h)){h=new Date(Date.parse(h))}return Ext.Date.dateFormat(h,i||Ext.Date.defaultFormat)},dateRenderer:function(h){return function(i){return g.date(i,h)}},stripTags:function(h){return !h?h:String(h).replace(e,"")},stripScripts:function(h){return !h?h:String(h).replace(c,"")},fileSize:function(h){if(h<1024){return h+" bytes"}else{if(h<1048576){return(Math.round(((h*10)/1024))/10)+" KB"}else{return(Math.round(((h*10)/1048576))/10)+" MB"}}},math:(function(){var h={};return function(j,i){if(!h[i]){h[i]=Ext.functionFactory("v","return v "+i+";")}return h[i](j)}}()),round:function(j,i){var h=Number(j);if(typeof i=="number"){i=Math.pow(10,i);h=Math.round(j*i)/i}return h},number:function(y,s){if(!s){return y}y=Ext.Number.from(y,NaN);if(isNaN(y)){return""}var A=g.thousandSeparator,q=g.decimalSeparator,z=false,r=y<0,k,h,x,w,p,t,o,l,u;y=Math.abs(y);if(s.substr(s.length-2)=="/i"){if(!a){a=new RegExp("[^\\d\\"+g.decimalSeparator+"]","g")}s=s.substr(0,s.length-2);z=true;k=s.indexOf(A)!=-1;h=s.replace(a,"").split(q)}else{k=s.indexOf(",")!=-1;h=s.replace(d,"").split(".")}if(h.length>2){}else{if(h.length>1){y=Ext.Number.toFixed(y,h[1].length)}else{y=Ext.Number.toFixed(y,0)}}x=y.toString();h=x.split(".");if(k){w=h[0];p=[];t=w.length;o=Math.floor(t/3);l=w.length%3||3;for(u=0;u<t;u+=l){if(u!==0){l=3}p[p.length]=w.substr(u,l);o-=1}x=p.join(A);if(h[1]){x+=q+h[1]}}else{if(h[1]){x=h[0]+q+h[1]}}if(r){r=x.replace(/[^1-9]/g,"")!==""}return(r?"-":"")+s.replace(/[\d,?\.?]+/,x)},numberRenderer:function(h){return function(i){return g.number(i,h)}},plural:function(h,i,j){return h+" "+(h==1?i:(j?j:i+"s"))},nl2br:function(h){return Ext.isEmpty(h)?"":h.replace(b,"<br/>")},capitalize:Ext.String.capitalize,ellipsis:Ext.String.ellipsis,format:Ext.String.format,htmlDecode:Ext.String.htmlDecode,htmlEncode:Ext.String.htmlEncode,leftPad:Ext.String.leftPad,trim:Ext.String.trim,parseBox:function(i){i=Ext.isEmpty(i)?"":i;if(Ext.isNumber(i)){i=i.toString()}var j=i.split(" "),h=j.length;if(h==1){j[1]=j[2]=j[3]=j[0]}else{if(h==2){j[2]=j[0];j[3]=j[1]}else{if(h==3){j[3]=j[1]}}}return{top:parseInt(j[0],10)||0,right:parseInt(j[1],10)||0,bottom:parseInt(j[2],10)||0,left:parseInt(j[3],10)||0}},escapeRegex:function(h){return h.replace(/([\-.*+?\^${}()|\[\]\/\\])/g,"\\$1")}})}());Ext.define("Ext.util.TaskRunner",{interval:10,timerId:null,constructor:function(a){var b=this;if(typeof a=="number"){b.interval=a}else{if(a){Ext.apply(b,a)}}b.tasks=[];b.timerFn=Ext.Function.bind(b.onTick,b)},newTask:function(b){var a=new Ext.util.TaskRunner.Task(b);a.manager=this;return a},start:function(a){var c=this,b=new Date().getTime();if(!a.pending){c.tasks.push(a);a.pending=true}a.stopped=false;a.taskStartTime=b;a.taskRunTime=a.fireOnStart!==false?0:a.taskStartTime;a.taskRunCount=0;if(!c.firing){if(a.fireOnStart!==false){c.startTimer(0,b)}else{c.startTimer(a.interval,b)}}return a},stop:function(a){if(!a.stopped){a.stopped=true;if(a.onStop){a.onStop.call(a.scope||a,a)}}return a},stopAll:function(){Ext.each(this.tasks,this.stop,this)},firing:false,nextExpires:1e+99,onTick:function(){var m=this,e=m.tasks,a=new Date().getTime(),n=1e+99,k=e.length,c,o,h,b,d,g;m.timerId=null;m.firing=true;for(h=0;h<k||h<(k=e.length);++h){b=e[h];if(!(g=b.stopped)){c=b.taskRunTime+b.interval;if(c<=a){d=1;try{d=b.run.apply(b.scope||b,b.args||[++b.taskRunCount])}catch(j){try{if(b.onError){d=b.onError.call(b.scope||b,b,j)}}catch(l){}}b.taskRunTime=a;if(d===false||b.taskRunCount===b.repeat){m.stop(b);g=true}else{g=b.stopped;c=a+b.interval}}if(!g&&b.duration&&b.duration<=(a-b.taskStartTime)){m.stop(b);g=true}}if(g){b.pending=false;if(!o){o=e.slice(0,h)}}else{if(o){o.push(b)}if(n>c){n=c}}}if(o){m.tasks=o}m.firing=false;if(m.tasks.length){m.startTimer(n-a,new Date().getTime())}},startTimer:function(e,c){var d=this,b=c+e,a=d.timerId;if(a&&d.nextExpires-b>d.interval){clearTimeout(a);a=null}if(!a){if(e<d.interval){e=d.interval}d.timerId=setTimeout(d.timerFn,e);d.nextExpires=b}}},function(){var b=this,a=b.prototype;a.destroy=a.stopAll;Ext.util.TaskManager=Ext.TaskManager=new b();b.Task=new Ext.Class({isTask:true,stopped:true,fireOnStart:false,constructor:function(c){Ext.apply(this,c)},restart:function(c){if(c!==undefined){this.interval=c}this.manager.start(this)},start:function(c){if(this.stopped){this.restart(c)}},stop:function(){this.manager.stop(this)}});a=b.Task.prototype;a.destroy=a.stop});Ext.define("Ext.perf.Accumulator",(function(){var c=null,h=Ext.global.chrome,d,b=function(){b=function(){return new Date().getTime()};var l,m;if(Ext.isChrome&&h&&h.Interval){l=new h.Interval();l.start();b=function(){return l.microseconds()/1000}}else{if(window.ActiveXObject){try{m=new ActiveXObject("SenchaToolbox.Toolbox");Ext.senchaToolbox=m;b=function(){return m.milliseconds}}catch(n){}}else{if(Date.now){b=Date.now}}}Ext.perf.getTimestamp=Ext.perf.Accumulator.getTimestamp=b;return b()};function i(m,l){m.sum+=l;m.min=Math.min(m.min,l);m.max=Math.max(m.max,l)}function e(o){var m=o?o:(b()-this.time),n=this,l=n.accum;++l.count;if(!--l.depth){i(l.total,m)}i(l.pure,m-n.childTime);c=n.parent;if(c){++c.accum.childCount;c.childTime+=m}}function a(){return{min:Number.MAX_VALUE,max:0,sum:0}}function j(m,l){return function(){var o=m.enter(),n=l.apply(this,arguments);o.leave();return n}}function k(l){return Math.round(l*100)/100}function g(n,m,l,p){var o={avg:0,min:p.min,max:p.max,sum:0};if(n){l=l||0;o.sum=p.sum-m*l;o.avg=o.sum/n}return o}return{constructor:function(l){var m=this;m.count=m.childCount=m.depth=m.maxDepth=0;m.pure=a();m.total=a();m.name=l},statics:{getTimestamp:b},format:function(l){if(!d){d=new Ext.XTemplate(["{name} - {count} call(s)",'<tpl if="count">','<tpl if="childCount">'," ({childCount} children)","</tpl>",'<tpl if="depth - 1">'," ({depth} deep)","</tpl>",'<tpl for="times">',", {type}: {[this.time(values.sum)]} msec (","avg={[this.time(values.sum / parent.count)]}",")","</tpl>","</tpl>"].join(""),{time:function(n){return Math.round(n*100)/100}})}var m=this.getData(l);m.name=this.name;m.pure.type="Pure";m.total.type="Total";m.times=[m.pure,m.total];return d.apply(m)},getData:function(l){var m=this;return{count:m.count,childCount:m.childCount,depth:m.maxDepth,pure:g(m.count,m.childCount,l,m.pure),total:g(m.count,m.childCount,l,m.total)}},enter:function(){var l=this,m={accum:l,leave:e,childTime:0,parent:c};++l.depth;if(l.maxDepth<l.depth){l.maxDepth=l.depth}c=m;m.time=b();return m},monitor:function(n,m,l){var o=this.enter();if(l){n.apply(m,l)}else{n.call(m)}o.leave()},report:function(){Ext.log(this.format())},tap:function(t,v){var u=this,o=typeof v=="string"?[v]:v,s,w,q,p,n,m,l,r;r=function(){if(typeof t=="string"){s=Ext.global;p=t.split(".");for(q=0,n=p.length;q<n;++q){s=s[p[q]]}}else{s=t}for(q=0,n=o.length;q<n;++q){m=o[q];w=m.charAt(0)=="!";if(w){m=m.substring(1)}else{w=!(m in s.prototype)}l=w?s:s.prototype;l[m]=j(u,l[m])}};Ext.ClassManager.onCreated(r,u,t);return u}}}()),function(){Ext.perf.getTimestamp=this.getTimestamp});Ext.define("Ext.perf.Monitor",{singleton:true,alternateClassName:"Ext.Perf",requires:["Ext.perf.Accumulator"],constructor:function(){this.accumulators=[];this.accumulatorsByName={}},calibrate:function(){var b=new Ext.perf.Accumulator("$"),g=b.total,c=Ext.perf.Accumulator.getTimestamp,e=0,h,a,d;d=c();do{h=b.enter();h.leave();++e}while(g.sum<100);a=c();return(a-d)/e},get:function(b){var c=this,a=c.accumulatorsByName[b];if(!a){c.accumulatorsByName[b]=a=new Ext.perf.Accumulator(b);c.accumulators.push(a)}return a},enter:function(a){return this.get(a).enter()},monitor:function(a,c,b){this.get(a).monitor(c,b)},report:function(){var c=this,b=c.accumulators,a=c.calibrate();b.sort(function(e,d){return(e.name<d.name)?-1:((d.name<e.name)?1:0)});c.updateGC();Ext.log("Calibration: "+Math.round(a*100)/100+" msec/sample");Ext.each(b,function(d){Ext.log(d.format(a))})},getData:function(c){var b={},a=this.accumulators;Ext.each(a,function(d){if(c||d.count){b[d.name]=d.getData()}});return b},reset:function(){Ext.each(this.accumulators,function(a){var b=a;b.count=b.childCount=b.depth=b.maxDepth=0;b.pure={min:Number.MAX_VALUE,max:0,sum:0};b.total={min:Number.MAX_VALUE,max:0,sum:0}})},updateGC:function(){var a=this.accumulatorsByName.GC,b=Ext.senchaToolbox,c;if(a){a.count=b.garbageCollectionCounter||0;if(a.count){c=a.pure;a.total.sum=c.sum=b.garbageCollectionMilliseconds;c.min=c.max=c.sum/a.count;c=a.total;c.min=c.max=c.sum/a.count}}},watchGC:function(){Ext.perf.getTimestamp();var a=Ext.senchaToolbox;if(a){this.get("GC");a.watchGarbageCollector(false)}},setup:function(c){if(!c){c={render:{"Ext.AbstractComponent":"render"},layout:{"Ext.layout.Context":"run"}}}this.currentConfig=c;var d,g,b,e,a;for(d in c){if(c.hasOwnProperty(d)){g=c[d];b=Ext.Perf.get(d);for(e in g){if(g.hasOwnProperty(e)){a=g[e];b.tap(e,a)}}}}this.watchGC()}});Ext.is={init:function(b){var c=this.platforms,e=c.length,d,a;b=b||window.navigator;for(d=0;d<e;d++){a=c[d];this[a.identity]=a.regex.test(b[a.property])}this.Desktop=this.Mac||this.Windows||(this.Linux&&!this.Android);this.Tablet=this.iPad;this.Phone=!this.Desktop&&!this.Tablet;this.iOS=this.iPhone||this.iPad||this.iPod;this.Standalone=!!window.navigator.standalone},platforms:[{property:"platform",regex:/iPhone/i,identity:"iPhone"},{property:"platform",regex:/iPod/i,identity:"iPod"},{property:"userAgent",regex:/iPad/i,identity:"iPad"},{property:"userAgent",regex:/Blackberry/i,identity:"Blackberry"},{property:"userAgent",regex:/Android/i,identity:"Android"},{property:"platform",regex:/Mac/i,identity:"Mac"},{property:"platform",regex:/Win/i,identity:"Windows"},{property:"platform",regex:/Linux/i,identity:"Linux"}]};Ext.is.init();(function(){var a=function(d,c){var b=d.ownerDocument.defaultView,e=(b?b.getComputedStyle(d,null):d.currentStyle)||d.style;return e[c]};Ext.supports={init:function(){var d=this,e=document,c=d.tests,i=c.length,h=i&&Ext.isReady&&e.createElement("div"),g,b=[];if(h){h.innerHTML=['<div style="height:30px;width:50px;">','<div style="height:20px;width:20px;"></div>',"</div>",'<div style="width: 200px; height: 200px; position: relative; padding: 5px;">','<div style="position: absolute; top: 0; left: 0; width: 100%; height: 100%;"></div>',"</div>",'<div style="position: absolute; left: 10%; top: 10%;"></div>','<div style="float:left; background-color:transparent;"></div>'].join("");e.body.appendChild(h)}while(i--){g=c[i];if(h||g.early){d[g.identity]=g.fn.call(d,e,h)}else{b.push(g)}}if(h){e.body.removeChild(h)}d.tests=b},PointerEvents:"pointerEvents" in document.documentElement.style,CSS3BoxShadow:"boxShadow" in document.documentElement.style||"WebkitBoxShadow" in document.documentElement.style||"MozBoxShadow" in document.documentElement.style,ClassList:!!document.documentElement.classList,OrientationChange:((typeof window.orientation!="undefined")&&("onorientationchange" in window)),DeviceMotion:("ondevicemotion" in window),Touch:("ontouchstart" in window)&&(!Ext.is.Desktop),TimeoutActualLateness:(function(){setTimeout(function(){Ext.supports.TimeoutActualLateness=arguments.length!==0},0)}()),tests:[{identity:"Transitions",fn:function(h,k){var g=["webkit","Moz","o","ms","khtml"],j="TransitionEnd",b=[g[0]+j,"transitionend",g[2]+j,g[3]+j,g[4]+j],e=g.length,d=0,c=false;for(;d<e;d++){if(a(k,g[d]+"TransitionProperty")){Ext.supports.CSS3Prefix=g[d];Ext.supports.CSS3TransitionEnd=b[d];c=true;break}}return c}},{identity:"RightMargin",fn:function(c,d){var b=c.defaultView;return !(b&&b.getComputedStyle(d.firstChild.firstChild,null).marginRight!="0px")}},{identity:"DisplayChangeInputSelectionBug",early:true,fn:function(){var b=Ext.webKitVersion;return 0<b&&b<533}},{identity:"DisplayChangeTextAreaSelectionBug",early:true,fn:function(){var b=Ext.webKitVersion;return 0<b&&b<534.24}},{identity:"TransparentColor",fn:function(c,d,b){b=c.defaultView;return !(b&&b.getComputedStyle(d.lastChild,null).backgroundColor!="transparent")}},{identity:"ComputedStyle",fn:function(c,d,b){b=c.defaultView;return b&&b.getComputedStyle}},{identity:"Svg",fn:function(b){return !!b.createElementNS&&!!b.createElementNS("http://www.w3.org/2000/svg","svg").createSVGRect}},{identity:"Canvas",fn:function(b){return !!b.createElement("canvas").getContext}},{identity:"Vml",fn:function(b){var c=b.createElement("div");c.innerHTML="<!--[if vml]><br/><br/><![endif]-->";return(c.childNodes.length==2)}},{identity:"Float",fn:function(b,c){return !!c.lastChild.style.cssFloat}},{identity:"AudioTag",fn:function(b){return !!b.createElement("audio").canPlayType}},{identity:"History",fn:function(){var b=window.history;return !!(b&&b.pushState)}},{identity:"CSS3DTransform",fn:function(){return(typeof WebKitCSSMatrix!="undefined"&&new WebKitCSSMatrix().hasOwnProperty("m41"))}},{identity:"CSS3LinearGradient",fn:function(h,j){var g="background-image:",d="-webkit-gradient(linear, left top, right bottom, from(black), to(white))",i="linear-gradient(left top, black, white)",e="-moz-"+i,b="-o-"+i,c=[g+d,g+i,g+e,g+b];j.style.cssText=c.join(";");return(""+j.style.backgroundImage).indexOf("gradient")!==-1}},{identity:"CSS3BorderRadius",fn:function(e,g){var c=["borderRadius","BorderRadius","MozBorderRadius","WebkitBorderRadius","OBorderRadius","KhtmlBorderRadius"],d=false,b;for(b=0;b<c.length;b++){if(document.body.style[c[b]]!==undefined){return true}}return d}},{identity:"GeoLocation",fn:function(){return(typeof navigator!="undefined"&&typeof navigator.geolocation!="undefined")||(typeof google!="undefined"&&typeof google.gears!="undefined")}},{identity:"MouseEnterLeave",fn:function(b,c){return("onmouseenter" in c&&"onmouseleave" in c)}},{identity:"MouseWheel",fn:function(b,c){return("onmousewheel" in c)}},{identity:"Opacity",fn:function(b,c){if(Ext.isIE6||Ext.isIE7||Ext.isIE8){return false}c.firstChild.style.cssText="opacity:0.73";return c.firstChild.style.opacity=="0.73"}},{identity:"Placeholder",fn:function(b){return"placeholder" in b.createElement("input")}},{identity:"Direct2DBug",fn:function(){return Ext.isString(document.body.style.msTransformOrigin)}},{identity:"BoundingClientRect",fn:function(b,c){return Ext.isFunction(c.getBoundingClientRect)}},{identity:"IncludePaddingInWidthCalculation",fn:function(b,c){return c.childNodes[1].firstChild.offsetWidth==210}},{identity:"IncludePaddingInHeightCalculation",fn:function(b,c){return c.childNodes[1].firstChild.offsetHeight==210}},{identity:"ArraySort",fn:function(){var b=[1,2,3,4,5].sort(function(){return 0});return b[0]===1&&b[1]===2&&b[2]===3&&b[3]===4&&b[4]===5}},{identity:"Range",fn:function(){return !!document.createRange}},{identity:"CreateContextualFragment",fn:function(){var b=Ext.supports.Range?document.createRange():false;return b&&!!b.createContextualFragment}},{identity:"WindowOnError",fn:function(){return Ext.isIE||Ext.isGecko||Ext.webKitVersion>=534.16}},{identity:"TextAreaMaxLength",fn:function(){var b=document.createElement("textarea");return("maxlength" in b)}},{identity:"GetPositionPercentage",fn:function(b,c){return a(c.childNodes[2],"left")=="10%"}}]}}());Ext.supports.init();Ext.util.DelayedTask=function(d,c,a){var e=this,g,b=function(){clearInterval(g);g=null;d.apply(c,a||[])};this.delay=function(i,k,j,h){e.cancel();d=k||d;c=j||c;a=h||a;g=setInterval(b,i)};this.cancel=function(){if(g){clearInterval(g);g=null}}};Ext.require("Ext.util.DelayedTask",function(){Ext.util.Event=Ext.extend(Object,(function(){var b={};function d(h,i,j,g){return function(){if(j.target===arguments[0]){h.apply(g,arguments)}}}function c(h,i,j,g){i.task=new Ext.util.DelayedTask();return function(){i.task.delay(j.buffer,h,g,Ext.Array.toArray(arguments))}}function a(h,i,j,g){return function(){var k=new Ext.util.DelayedTask();if(!i.tasks){i.tasks=[]}i.tasks.push(k);k.delay(j.delay||10,h,g,Ext.Array.toArray(arguments))}}function e(h,i,j,g){return function(){var k=i.ev;if(k.removeListener(i.fn,g)&&k.observable){k.observable.hasListeners[k.name]--}return h.apply(g,arguments)}}return{isEvent:true,constructor:function(h,g){this.name=g;this.observable=h;this.listeners=[]},addListener:function(i,h,g){var j=this,k;h=h||j.observable;if(!j.isListening(i,h)){k=j.createListener(i,h,g);if(j.firing){j.listeners=j.listeners.slice(0)}j.listeners.push(k)}},createListener:function(j,i,g){g=g||b;i=i||this.observable;var k={fn:j,scope:i,o:g,ev:this},h=j;if(g.single){h=e(h,k,g,i)}if(g.target){h=d(h,k,g,i)}if(g.delay){h=a(h,k,g,i)}if(g.buffer){h=c(h,k,g,i)}k.fireFn=h;return k},findListener:function(l,k){var j=this.listeners,g=j.length,m,h;while(g--){m=j[g];if(m){h=m.scope;if(m.fn==l&&(h==(k||this.observable))){return g}}}return -1},isListening:function(h,g){return this.findListener(h,g)!==-1},removeListener:function(j,i){var l=this,h,m,g;h=l.findListener(j,i);if(h!=-1){m=l.listeners[h];if(l.firing){l.listeners=l.listeners.slice(0)}if(m.task){m.task.cancel();delete m.task}g=m.tasks&&m.tasks.length;if(g){while(g--){m.tasks[g].cancel()}delete m.tasks}Ext.Array.erase(l.listeners,h,1);return true}return false},clearListeners:function(){var h=this.listeners,g=h.length;while(g--){this.removeListener(h[g].fn,h[g].scope)}},fire:function(){var l=this,j=l.listeners,k=j.length,h,g,m;if(k>0){l.firing=true;for(h=0;h<k;h++){m=j[h];g=arguments.length?Array.prototype.slice.call(arguments,0):[];if(m.o){g.push(m.o)}if(m&&m.fireFn.apply(m.scope||l.observable,g)===false){return(l.firing=false)}}}l.firing=false;return true}}}()))});Ext.define("Ext.util.Observable",{requires:["Ext.util.Event"],statics:{releaseCapture:function(a){a.fireEvent=this.prototype.fireEvent},capture:function(c,b,a){c.fireEvent=Ext.Function.createInterceptor(c.fireEvent,b,a)},observe:function(a,b){if(a){if(!a.isObservable){Ext.applyIf(a,new this());this.capture(a.prototype,a.fireEvent,a)}if(Ext.isObject(b)){a.on(b)}}return a},prepareClass:function(d,c){if(!d.HasListeners){var b=Ext.util.Observable,e=function(){},a=d.superclass.HasListeners||(c&&c.HasListeners)||b.HasListeners;d.prototype.HasListeners=d.HasListeners=e;e.prototype=d.hasListeners=new a()}}},isObservable:true,eventsSuspended:0,constructor:function(a){var b=this;Ext.apply(b,a);if(!b.hasListeners){b.hasListeners=new b.HasListeners()}b.events=b.events||{};if(b.listeners){b.on(b.listeners);b.listeners=null}if(b.bubbleEvents){b.enableBubble(b.bubbleEvents)}},onClassExtended:function(a){if(!a.HasListeners){Ext.util.Observable.prepareClass(a)}},eventOptionsRe:/^(?:scope|delay|buffer|single|stopEvent|preventDefault|stopPropagation|normalized|args|delegate|element|vertical|horizontal|freezeEvent)$/,addManagedListener:function(i,d,g,e,c){var h=this,a=h.managedListeners=h.managedListeners||[],b;if(typeof d!=="string"){c=d;for(d in c){if(c.hasOwnProperty(d)){b=c[d];if(!h.eventOptionsRe.test(d)){h.addManagedListener(i,d,b.fn||b,b.scope||c.scope,b.fn?b:c)}}}}else{a.push({item:i,ename:d,fn:g,scope:e,options:c});i.on(d,g,e,c)}},removeManagedListener:function(j,c,g,k){var e=this,l,b,h,a,d;if(typeof c!=="string"){l=c;for(c in l){if(l.hasOwnProperty(c)){b=l[c];if(!e.eventOptionsRe.test(c)){e.removeManagedListener(j,c,b.fn||b,b.scope||l.scope)}}}}h=e.managedListeners?e.managedListeners.slice():[];for(d=0,a=h.length;d<a;d++){e.removeManagedListenerItem(false,h[d],j,c,g,k)}},fireEvent:function(a){a=a.toLowerCase();var e=this,c=e.events,d=c&&c[a],b=true;if(d&&e.hasListeners[a]){b=e.continueFireEvent(a,Ext.Array.slice(arguments,1),d.bubble)}return b},continueFireEvent:function(c,e,b){var h=this,a,g,d=true;do{if(h.eventsSuspended){if((a=h.eventQueue)){a.push([c,e,b])}return d}else{g=h.events[c];if(g&&g!=true){if((d=g.fire.apply(g,e))===false){break}}}}while(b&&(h=h.getBubbleParent()));return d},getBubbleParent:function(){var b=this,a=b.getBubbleTarget&&b.getBubbleTarget();if(a&&a.isObservable){return a}return null},addListener:function(c,g,i,j){var e=this,b,a,d,h=0;if(typeof c!=="string"){j=c;for(c in j){if(j.hasOwnProperty(c)){b=j[c];if(!e.eventOptionsRe.test(c)){e.addListener(c,b.fn||b,b.scope||j.scope,b.fn?b:j)}}}}else{c=c.toLowerCase();a=e.events[c];if(a&&a.isEvent){h=a.listeners.length}else{e.events[c]=a=new Ext.util.Event(e,c)}if(typeof g==="string"){g=i[g]||e[g]}a.addListener(g,i,j);if(a.listeners.length!==h){d=e.hasListeners;if(d.hasOwnProperty(c)){++d[c]}else{d[c]=1}}}},removeListener:function(c,e,d){var h=this,b,g,a;if(typeof c!=="string"){a=c;for(c in a){if(a.hasOwnProperty(c)){b=a[c];if(!h.eventOptionsRe.test(c)){h.removeListener(c,b.fn||b,b.scope||a.scope)}}}}else{c=c.toLowerCase();g=h.events[c];if(g&&g.isEvent){if(g.removeListener(e,d)&&!--h.hasListeners[c]){delete h.hasListeners[c]}}}},clearListeners:function(){var b=this.events,c,a;for(a in b){if(b.hasOwnProperty(a)){c=b[a];if(c.isEvent){c.clearListeners()}}}this.clearManagedListeners()},clearManagedListeners:function(){var b=this.managedListeners||[],c=0,a=b.length;for(;c<a;c++){this.removeManagedListenerItem(true,b[c])}this.managedListeners=[]},removeManagedListenerItem:function(b,a,g,c,e,d){if(b||(a.item===g&&a.ename===c&&(!e||a.fn===e)&&(!d||a.scope===d))){a.item.un(a.ename,a.fn,a.scope);if(!b){Ext.Array.remove(this.managedListeners,a)}}},addEvents:function(g){var e=this,d=e.events||(e.events={}),a,b,c;if(typeof g=="string"){for(b=arguments,c=b.length;c--;){a=b[c];if(!d[a]){d[a]=true}}}else{Ext.applyIf(e.events,g)}},hasListener:function(a){return !!this.hasListeners[a.toLowerCase()]},suspendEvents:function(a){this.eventsSuspended+=1;if(a&&!this.eventQueue){this.eventQueue=[]}},resumeEvents:function(){var a=this,d=a.eventQueue,c,b;if(a.eventsSuspended&&!--a.eventsSuspended){delete a.eventQueue;if(d){c=d.length;for(b=0;b<c;b++){a.continueFireEvent.apply(a,d[b])}}}},relayEvents:function(c,e,j){var h=this,a=e.length,d=0,g,b;for(;d<a;d++){g=e[d];b=j?j+g:g;h.mon(c,g,h.createRelayer(b))}},createRelayer:function(a,b){var c=this;return function(){return c.fireEvent.apply(c,[a].concat(Array.prototype.slice.apply(arguments,b||[0,-1])))}},enableBubble:function(j){if(j){var g=this,h=(typeof j=="string")?arguments:j,e=h.length,c=g.events,b,d,a;for(a=0;a<e;++a){b=h[a].toLowerCase();d=c[b];if(!d||typeof d=="boolean"){c[b]=d=new Ext.util.Event(g,b)}g.hasListeners[b]=(g.hasListeners[b]||0)+1;d.bubble=true}}}},function(){var a=this,d=a.prototype,b=function(){},e=function(g){if(!g.HasListeners){var h=g.prototype;a.prepareClass(g,this);g.onExtended(function(i){a.prepareClass(i)});if(h.onClassMixedIn){Ext.override(g,{onClassMixedIn:function(i){e.call(this,i);this.callParent(arguments)}})}else{h.onClassMixedIn=function(i){e.call(this,i)}}}};b.prototype={};d.HasListeners=a.HasListeners=b;a.createAlias({on:"addListener",un:"removeListener",mon:"addManagedListener",mun:"removeManagedListener"});a.observeClass=a.observe;function c(m){var l=(this.methodEvents=this.methodEvents||{})[m],i,h,j,k=this,g;if(!l){this.methodEvents[m]=l={};l.originalFn=this[m];l.methodName=m;l.before=[];l.after=[];g=function(p,o,n){if((h=p.apply(o||k,n))!==undefined){if(typeof h=="object"){if(h.returnValue!==undefined){i=h.returnValue}else{i=h}j=!!h.cancel}else{if(h===false){j=true}else{i=h}}}};this[m]=function(){var p=Array.prototype.slice.call(arguments,0),o,q,n;i=h=undefined;j=false;for(q=0,n=l.before.length;q<n;q++){o=l.before[q];g(o.fn,o.scope,p);if(j){return i}}if((h=l.originalFn.apply(k,p))!==undefined){i=h}for(q=0,n=l.after.length;q<n;q++){o=l.after[q];g(o.fn,o.scope,p);if(j){return i}}return i}}return l}Ext.apply(d,{onClassMixedIn:e,beforeMethod:function(i,h,g){c.call(this,i).before.push({fn:h,scope:g})},afterMethod:function(i,h,g){c.call(this,i).after.push({fn:h,scope:g})},removeMethodListener:function(m,k,j){var l=this.getMethodEvent(m),h,g;for(h=0,g=l.before.length;h<g;h++){if(l.before[h].fn==k&&l.before[h].scope==j){Ext.Array.erase(l.before,h,1);return}}for(h=0,g=l.after.length;h<g;h++){if(l.after[h].fn==k&&l.after[h].scope==j){Ext.Array.erase(l.after,h,1);return}}},toggleEventLogging:function(g){Ext.util.Observable[g?"capture":"releaseCapture"](this,function(h){if(Ext.isDefined(Ext.global.console)){Ext.global.console.log(h,arguments)}})}})});Ext.define("Ext.util.HashMap",{mixins:{observable:"Ext.util.Observable"},constructor:function(a){a=a||{};var c=this,b=a.keyFn;c.addEvents("add","clear","remove","replace");c.mixins.observable.constructor.call(c,a);c.clear(true);if(b){c.getKey=b}},getCount:function(){return this.length},getData:function(a,b){if(b===undefined){b=a;a=this.getKey(b)}return[a,b]},getKey:function(a){return a.id},add:function(a,c){var b=this;if(c===undefined){c=a;a=b.getKey(c)}if(b.containsKey(a)){return b.replace(a,c)}b.map[a]=c;++b.length;if(b.hasListeners.add){b.fireEvent("add",b,a,c)}return c},replace:function(b,d){var c=this,e=c.map,a;if(d===undefined){d=b;b=c.getKey(d)}if(!c.containsKey(b)){c.add(b,d)}a=e[b];e[b]=d;if(c.hasListeners.replace){c.fireEvent("replace",c,b,d,a)}return d},remove:function(b){var a=this.findKey(b);if(a!==undefined){return this.removeAtKey(a)}return false},removeAtKey:function(a){var b=this,c;if(b.containsKey(a)){c=b.map[a];delete b.map[a];--b.length;if(b.hasListeners.remove){b.fireEvent("remove",b,a,c)}return true}return false},get:function(a){return this.map[a]},clear:function(a){var b=this;b.map={};b.length=0;if(a!==true&&b.hasListeners.clear){b.fireEvent("clear",b)}return b},containsKey:function(a){return this.map[a]!==undefined},contains:function(a){return this.containsKey(this.findKey(a))},getKeys:function(){return this.getArray(true)},getValues:function(){return this.getArray(false)},getArray:function(d){var a=[],b,c=this.map;for(b in c){if(c.hasOwnProperty(b)){a.push(d?b:c[b])}}return a},each:function(d,c){var a=Ext.apply({},this.map),b,e=this.length;c=c||this;for(b in a){if(a.hasOwnProperty(b)){if(d.call(c,b,a[b],e)===false){break}}}return this},clone:function(){var c=new this.self(),b=this.map,a;c.suspendEvents();for(a in b){if(b.hasOwnProperty(a)){c.add(a,b[a])}}c.resumeEvents();return c},findKey:function(b){var a,c=this.map;for(a in c){if(c.hasOwnProperty(a)&&c[a]===b){return a}}return undefined}});Ext.define("Ext.AbstractManager",{requires:["Ext.util.HashMap"],typeName:"type",constructor:function(a){Ext.apply(this,a||{});this.all=new Ext.util.HashMap();this.types={}},get:function(a){return this.all.get(a)},register:function(a){this.all.add(a)},unregister:function(a){this.all.remove(a)},registerType:function(b,a){this.types[b]=a;a[this.typeName]=b},isRegistered:function(a){return this.types[a]!==undefined},create:function(a,d){var b=a[this.typeName]||a.type||d,c=this.types[b];return new c(a)},onAvailable:function(g,c,b){var a=this.all,d,e;if(a.containsKey(g)){d=a.get(g);c.call(b||d,d)}else{e=function(j,h,i){if(h==g){c.call(b||i,i);a.un("add",e)}};a.on("add",e)}},each:function(b,a){this.all.each(b,a||this)},getCount:function(){return this.all.getCount()}});Ext.define("Ext.ComponentManager",{extend:"Ext.AbstractManager",alternateClassName:"Ext.ComponentMgr",singleton:true,typeName:"xtype",create:function(a,b){if(typeof a=="string"){return Ext.widget(a)}if(a.isComponent){return a}return Ext.widget(a.xtype||b,a)},registerType:function(b,a){this.types[b]=a;a[this.typeName]=b;a.prototype[this.typeName]=b}});Ext.define("Ext.ComponentQuery",{singleton:true,requires:["Ext.ComponentManager"]},function(){var h=this,k=["var r = [],","i = 0,","it = items,","l = it.length,","c;","for (; i < l; i++) {","c = it[i];","if (c.{0}) {","r.push(c);","}","}","return r;"].join(""),e=function(p,o){return o.method.apply(this,[p].concat(o.args))},a=function(q,u){var o=[],r=0,t=q.length,s,p=u!==">";for(;r<t;r++){s=q[r];if(s.getRefItems){o=o.concat(s.getRefItems(p))}}return o},g=function(p){var o=[],q=0,s=p.length,r;for(;q<s;q++){r=p[q];while(!!(r=(r.ownerCt||r.floatParent))){o.push(r)}}return o},m=function(p,u,t){if(u==="*"){return p.slice()}else{var o=[],q=0,s=p.length,r;for(;q<s;q++){r=p[q];if(r.isXType(u,t)){o.push(r)}}return o}},j=function(p,s){var u=Ext.Array,o=[],q=0,t=p.length,r;for(;q<t;q++){r=p[q];if(r.hasCls(s)){o.push(r)}}return o},n=function(q,v,p,u){var o=[],r=0,t=q.length,s;for(;r<t;r++){s=q[r];if(!u?!!s[v]:(String(s[v])===u)){o.push(s)}}return o},d=function(p,t){var o=[],q=0,s=p.length,r;for(;q<s;q++){r=p[q];if(r.getItemId()===t){o.push(r)}}return o},l=function(o,p,q){return h.pseudos[p](o,q)},i=/^(\s?([>\^])\s?|\s|$)/,c=/^(#)?([\w\-]+|\*)(?:\((true|false)\))?/,b=[{re:/^\.([\w\-]+)(?:\((true|false)\))?/,method:m},{re:/^(?:[\[](?:@)?([\w\-]+)\s?(?:(=|.=)\s?['"]?(.*?)["']?)?[\]])/,method:n},{re:/^#([\w\-]+)/,method:d},{re:/^\:([\w\-]+)(?:\(((?:\{[^\}]+\})|(?:(?!\{)[^\s>\/]*?(?!\})))\))?/,method:l},{re:/^(?:\{([^\}]+)\})/,method:k}];h.Query=Ext.extend(Object,{constructor:function(o){o=o||{};Ext.apply(this,o)},execute:function(p){var r=this.operations,s=0,t=r.length,q,o;if(!p){o=Ext.ComponentManager.all.getArray()}else{if(Ext.isArray(p)){o=p}else{if(p.isMixedCollection){o=p.items}}}for(;s<t;s++){q=r[s];if(q.mode==="^"){o=g(o||[p])}else{if(q.mode){o=a(o||[p],q.mode)}else{o=e(o||a([p]),q)}}if(s===t-1){return o}}return[]},is:function(q){var p=this.operations,t=Ext.isArray(q)?q:[q],o=t.length,u=p[p.length-1],s,r;t=e(t,u);if(t.length===o){if(p.length>1){for(r=0,s=t.length;r<s;r++){if(Ext.Array.indexOf(this.execute(),t[r])===-1){return false}}}return true}return false}});Ext.apply(this,{cache:{},pseudos:{not:function(u,o){var v=Ext.ComponentQuery,s=0,t=u.length,r=[],q=-1,p;for(;s<t;++s){p=u[s];if(!v.is(p,o)){r[++q]=p}}return r},first:function(p){var o=[];if(p.length>0){o.push(p[0])}return o},last:function(q){var o=q.length,p=[];if(o>0){p.push(q[o-1])}return p}},query:function(p,w){var x=p.split(","),o=x.length,q=0,r=[],y=[],v={},t,s,u;for(;q<o;q++){p=Ext.String.trim(x[q]);t=this.cache[p]||(this.cache[p]=this.parse(p));r=r.concat(t.execute(w))}if(o>1){s=r.length;for(q=0;q<s;q++){u=r[q];if(!v[u.id]){y.push(u);v[u.id]=true}}r=y}return r},is:function(p,o){if(!o){return true}var r=o.split(","),s=r.length,q=0,t;for(;q<s;q++){o=Ext.String.trim(r[q]);t=this.cache[o]||(this.cache[o]=this.parse(o));if(t.is(p)){return true}}return false},parse:function(r){var p=[],q=b.length,v,s,w,x,y,t,u,o;while(r&&v!==r){v=r;s=r.match(c);if(s){w=s[1];if(w==="#"){p.push({method:d,args:[Ext.String.trim(s[2])]})}else{if(w==="."){p.push({method:j,args:[Ext.String.trim(s[2])]})}else{p.push({method:m,args:[Ext.String.trim(s[2]),Boolean(s[3])]})}}r=r.replace(s[0],"")}while(!(x=r.match(i))){for(t=0;r&&t<q;t++){u=b[t];y=r.match(u.re);o=u.method;if(y){p.push({method:Ext.isString(u.method)?Ext.functionFactory("items",Ext.String.format.apply(Ext.String,[o].concat(y.slice(1)))):u.method,args:y.slice(1)});r=r.replace(y[0],"");break}if(t===(q-1)){Ext.Error.raise('Invalid ComponentQuery selector: "'+arguments[0]+'"')}}}if(x[1]){p.push({mode:x[2]||x[1]});r=r.replace(x[0],"")}}return new h.Query({operations:p})}})});Ext.define("Ext.util.ProtoElement",(function(){var b=Ext.String.splitWords,a=Ext.Array.toMap;return{isProtoEl:true,clsProp:"cls",styleProp:"style",removedProp:"removed",styleIsText:false,constructor:function(c){var d=this;Ext.apply(d,c);d.classList=b(d.cls);d.classMap=a(d.classList);delete d.cls;if(Ext.isFunction(d.style)){d.styleFn=d.style;delete d.style}else{if(typeof d.style=="string"){d.style=Ext.Element.parseStyles(d.style)}else{if(d.style){d.style=Ext.apply({},d.style)}}}},flush:function(){this.flushClassList=[];this.removedClasses={};delete this.style},addCls:function(n){var l=this,m=b(n),e=m.length,j=l.classList,d=l.classMap,g=l.flushClassList,h=0,k;for(;h<e;++h){k=m[h];if(!d[k]){d[k]=true;j.push(k);if(g){g.push(k);delete l.removedClasses[k]}}}return l},hasCls:function(c){return c in this.classMap},removeCls:function(o){var n=this,l=n.classList,g=(n.classList=[]),j=a(b(o)),e=l.length,d=n.classMap,k=n.removedClasses,h,m;for(h=0;h<e;++h){m=l[h];if(j[m]){if(k){if(d[m]){k[m]=true;Ext.Array.remove(n.flushClassList,m)}}delete d[m]}else{g.push(m)}}return n},setStyle:function(g,e){var d=this,c=d.style||(d.style={});if(typeof g=="string"){if(arguments.length===1){d.setStyle(Ext.Element.parseStyles(g))}else{c[g]=e}}else{Ext.apply(c,g)}return d},writeTo:function(h){var e=this,g=e.flushClassList||e.classList,d=e.removedClasses,c;if(e.styleFn){c=Ext.apply({},e.styleFn());Ext.apply(c,e.style)}else{c=e.style}h[e.clsProp]=g.join(" ");if(c){h[e.styleProp]=e.styleIsText?Ext.DomHelper.generateStyles(c):c}if(d){d=Ext.Object.getKeys(d);if(d.length){h[e.removedProp]=d.join(" ")}}return h}}}()));Ext.EventManager=new function(){var a=this,d=document,c=window,b=function(){var k=d.body||d.getElementsByTagName("body")[0],i=Ext.baseCSSPrefix,o=[i+"body"],g=[],m=Ext.supports.CSS3LinearGradient,l=Ext.supports.CSS3BorderRadius,h=[],j,e;if(!k){return false}j=k.parentNode;function n(p){o.push(i+p)}if(Ext.isIE){n("ie");if(Ext.isIE6){n("ie6")}else{n("ie7p");if(Ext.isIE7){n("ie7")}else{n("ie8p");if(Ext.isIE8){n("ie8")}else{n("ie9p");if(Ext.isIE9){n("ie9")}}}}if(Ext.isIE6||Ext.isIE7){n("ie7m")}if(Ext.isIE6||Ext.isIE7||Ext.isIE8){n("ie8m")}if(Ext.isIE7||Ext.isIE8){n("ie78")}}if(Ext.isGecko){n("gecko");if(Ext.isGecko3){n("gecko3")}if(Ext.isGecko4){n("gecko4")}if(Ext.isGecko5){n("gecko5")}}if(Ext.isOpera){n("opera")}if(Ext.isWebKit){n("webkit")}if(Ext.isSafari){n("safari");if(Ext.isSafari2){n("safari2")}if(Ext.isSafari3){n("safari3")}if(Ext.isSafari4){n("safari4")}if(Ext.isSafari5){n("safari5")}if(Ext.isSafari5_0){n("safari5_0")}}if(Ext.isChrome){n("chrome")}if(Ext.isMac){n("mac")}if(Ext.isLinux){n("linux")}if(!l){n("nbr")}if(!m){n("nlg")}if(Ext.scopeResetCSS){e=Ext.resetElementSpec={cls:i+"reset"};if(!m){h.push(i+"nlg")}if(!l){h.push(i+"nbr")}if(h.length){e.cn={cls:h.join(" ")}}Ext.resetElement=Ext.getBody().createChild(e);if(h.length){Ext.resetElement=Ext.get(Ext.resetElement.dom.firstChild)}}else{Ext.resetElement=Ext.getBody();n("reset")}if(j){if(Ext.isStrict&&(Ext.isIE6||Ext.isIE7)){Ext.isBorderBox=false}else{Ext.isBorderBox=true}if(Ext.isBorderBox){g.push(i+"border-box")}if(Ext.isStrict){g.push(i+"strict")}else{g.push(i+"quirks")}Ext.fly(j,"_internal").addCls(g)}Ext.fly(k,"_internal").addCls(o);return true};Ext.apply(a,{hasBoundOnReady:false,hasFiredReady:false,deferReadyEvent:1,onReadyChain:[],readyEvent:(function(){var e=new Ext.util.Event();e.fire=function(){Ext._beforeReadyTime=Ext._beforeReadyTime||new Date().getTime();e.self.prototype.fire.apply(e,arguments);Ext._afterReadytime=new Date().getTime()};return e}()),idleEvent:new Ext.util.Event(),isReadyPaused:function(){return(/[?&]ext-pauseReadyFire\b/i.test(location.search)&&!Ext._continueFireReady)},bindReadyEvent:function(){if(a.hasBoundOnReady){return}if(d.readyState=="complete"){a.onReadyEvent({type:d.readyState||"body"})}else{document.addEventListener("DOMContentLoaded",a.onReadyEvent,false);window.addEventListener("load",a.onReadyEvent,false);a.hasBoundOnReady=true}},onReadyEvent:function(g){if(g&&g.type){a.onReadyChain.push(g.type)}if(a.hasBoundOnReady){document.removeEventListener("DOMContentLoaded",a.onReadyEvent,false);window.removeEventListener("load",a.onReadyEvent,false)}if(!Ext.isReady){a.fireDocReady()}},fireDocReady:function(){if(!Ext.isReady){Ext._readyTime=new Date().getTime();Ext.isReady=true;Ext.supports.init();a.onWindowUnload();a.readyEvent.onReadyChain=a.onReadyChain;if(Ext.isNumber(a.deferReadyEvent)){Ext.Function.defer(a.fireReadyEvent,a.deferReadyEvent);a.hasDocReadyTimer=true}else{a.fireReadyEvent()}}},fireReadyEvent:function(){var e=a.readyEvent;a.hasDocReadyTimer=false;a.isFiring=true;while(e.listeners.length&&!a.isReadyPaused()){e.fire()}a.isFiring=false;a.hasFiredReady=true},onDocumentReady:function(h,g,e){e=e||{};e.single=true;a.readyEvent.addListener(h,g,e);if(!(a.isFiring||a.hasDocReadyTimer)){if(Ext.isReady){a.fireReadyEvent()}else{a.bindReadyEvent()}}},stoppedMouseDownEvent:new Ext.util.Event(),propRe:/^(?:scope|delay|buffer|single|stopEvent|preventDefault|stopPropagation|normalized|args|delegate|freezeEvent)$/,getId:function(e){var g;e=Ext.getDom(e);if(e===d||e===c){g=e===d?Ext.documentId:Ext.windowId}else{g=Ext.id(e)}if(!Ext.cache[g]){Ext.addCacheEntry(g,null,e)}return g},prepareListenerConfig:function(i,g,k){var l=a.propRe,h,j,e;for(h in g){if(g.hasOwnProperty(h)){if(!l.test(h)){j=g[h];if(typeof j=="function"){e=[i,h,j,g.scope,g]}else{e=[i,h,j.fn,j.scope,j]}if(k){a.removeListener.apply(a,e)}else{a.addListener.apply(a,e)}}}}},mouseEnterLeaveRe:/mouseenter|mouseleave/,normalizeEvent:function(e,g){if(a.mouseEnterLeaveRe.test(e)&&!Ext.supports.MouseEnterLeave){if(g){g=Ext.Function.createInterceptor(g,a.contains)}e=e=="mouseenter"?"mouseover":"mouseout"}else{if(e=="mousewheel"&&!Ext.supports.MouseWheel&&!Ext.isOpera){e="DOMMouseScroll"}}return{eventName:e,fn:g}},contains:function(g){var e=g.browserEvent.currentTarget,h=a.getRelatedTarget(g);if(e&&e.firstChild){while(h){if(h===e){return false}h=h.parentNode;if(h&&(h.nodeType!=1)){h=null}}}return true},addListener:function(h,e,k,j,g){if(typeof e!=="string"){a.prepareListenerConfig(h,e);return}var l=h.dom||Ext.getDom(h),m,i;g=g||{};m=a.normalizeEvent(e,k);i=a.createListenerWrap(l,e,m.fn,j,g);if(l.attachEvent){l.attachEvent("on"+m.eventName,i)}else{l.addEventListener(m.eventName,i,g.capture||false)}if(l==d&&e=="mousedown"){a.stoppedMouseDownEvent.addListener(i)}a.getEventListenerCache(h.dom?h:l,e).push({fn:k,wrap:i,scope:j})},removeListener:function(p,q,r,t){if(typeof q!=="string"){a.prepareListenerConfig(p,q,true);return}var n=Ext.getDom(p),h=p.dom?p:Ext.get(n),e=a.getEventListenerCache(h,q),s=a.normalizeEvent(q).eventName,o=e.length,m,k,g,l;while(o--){k=e[o];if(k&&(!r||k.fn==r)&&(!t||k.scope===t)){g=k.wrap;if(g.task){clearTimeout(g.task);delete g.task}m=g.tasks&&g.tasks.length;if(m){while(m--){clearTimeout(g.tasks[m])}delete g.tasks}if(n.detachEvent){n.detachEvent("on"+s,g)}else{n.removeEventListener(s,g,false)}if(g&&n==d&&q=="mousedown"){a.stoppedMouseDownEvent.removeListener(g)}Ext.Array.erase(e,o,1)}}},removeAll:function(i){var j=i.dom?i:Ext.get(i),g,h,e;if(!j){return}g=(j.$cache||j.getCache());h=g.events;for(e in h){if(h.hasOwnProperty(e)){a.removeListener(j,e)}}g.events={}},purgeElement:function(j,g){var k=Ext.getDom(j),h=0,e;if(g){a.removeListener(j,g)}else{a.removeAll(j)}if(k&&k.childNodes){for(e=j.childNodes.length;h<e;h++){a.purgeElement(j.childNodes[h],g)}}},createListenerWrap:function(i,h,l,m,n){n=n||{};var k,j,e=/\\/g,g=function(p,o){if(!j){k=["if(!"+Ext.name+") {return;}"];if(n.buffer||n.delay||n.freezeEvent){k.push("e = new X.EventObjectImpl(e, "+(n.freezeEvent?"true":"false")+");")}else{k.push("e = X.EventObject.setEvent(e);")}if(n.delegate){k.push('var result, t = e.getTarget("'+(n.delegate+"").replace(e,"\\\\")+'", this);');k.push("if(!t) {return;}")}else{k.push("var t = e.target, result;")}if(n.target){k.push("if(e.target !== options.target) {return;}")}if(n.stopEvent){k.push("e.stopEvent();")}else{if(n.preventDefault){k.push("e.preventDefault();")}if(n.stopPropagation){k.push("e.stopPropagation();")}}if(n.normalized===false){k.push("e = e.browserEvent;")}if(n.buffer){k.push("(wrap.task && clearTimeout(wrap.task));");k.push("wrap.task = setTimeout(function() {")}if(n.delay){k.push("wrap.tasks = wrap.tasks || [];");k.push("wrap.tasks.push(setTimeout(function() {")}k.push("result = fn.call(scope || dom, e, t, options);");if(n.single){k.push("evtMgr.removeListener(dom, ename, fn, scope);")}if(h!=="mousemove"){k.push("if (evtMgr.idleEvent.listeners.length) {");k.push("evtMgr.idleEvent.fire();");k.push("}")}if(n.delay){k.push("}, "+n.delay+"));")}if(n.buffer){k.push("}, "+n.buffer+");")}k.push("return result;");j=Ext.cacheableFunctionFactory("e","options","fn","scope","ename","dom","wrap","args","X","evtMgr",k.join("\n"))}return j.call(i,p,n,l,m,h,i,g,o,Ext,a)};return g},getEventListenerCache:function(i,e){var h,g;if(!i){return[]}if(i.$cache){h=i.$cache}else{h=Ext.cache[a.getId(i)]}g=h.events||(h.events={});return g[e]||(g[e]=[])},mouseLeaveRe:/(mouseout|mouseleave)/,mouseEnterRe:/(mouseover|mouseenter)/,stopEvent:function(e){a.stopPropagation(e);a.preventDefault(e)},stopPropagation:function(e){e=e.browserEvent||e;if(e.stopPropagation){e.stopPropagation()}else{e.cancelBubble=true}},preventDefault:function(g){g=g.browserEvent||g;if(g.preventDefault){g.preventDefault()}else{g.returnValue=false;try{if(g.ctrlKey||g.keyCode>111&&g.keyCode<124){g.keyCode=-1}}catch(h){}}},getRelatedTarget:function(e){e=e.browserEvent||e;var g=e.relatedTarget;if(!g){if(a.mouseLeaveRe.test(e.type)){g=e.toElement}else{if(a.mouseEnterRe.test(e.type)){g=e.fromElement}}}return a.resolveTextNode(g)},getPageX:function(e){return a.getPageXY(e)[0]},getPageY:function(e){return a.getPageXY(e)[1]},getPageXY:function(h){h=h.browserEvent||h;var g=h.pageX,j=h.pageY,i=d.documentElement,e=d.body;if(!g&&g!==0){g=h.clientX+(i&&i.scrollLeft||e&&e.scrollLeft||0)-(i&&i.clientLeft||e&&e.clientLeft||0);j=h.clientY+(i&&i.scrollTop||e&&e.scrollTop||0)-(i&&i.clientTop||e&&e.clientTop||0)}return[g,j]},getTarget:function(e){e=e.browserEvent||e;return a.resolveTextNode(e.target||e.srcElement)},resolveTextNode:Ext.isGecko?function(g){if(!g){return}var e=HTMLElement.prototype.toString.call(g);if(e=="[xpconnect wrapped native prototype]"||e=="[object XULElement]"){return}return g.nodeType==3?g.parentNode:g}:function(e){return e&&e.nodeType==3?e.parentNode:e},curWidth:0,curHeight:0,onWindowResize:function(i,h,g){var e=a.resizeEvent;if(!e){a.resizeEvent=e=new Ext.util.Event();a.on(c,"resize",a.fireResize,null,{buffer:100})}e.addListener(i,h,g)},fireResize:function(){var e=Ext.Element.getViewWidth(),g=Ext.Element.getViewHeight();if(a.curHeight!=g||a.curWidth!=e){a.curHeight=g;a.curWidth=e;a.resizeEvent.fire(e,g)}},removeResizeListener:function(h,g){var e=a.resizeEvent;if(e){e.removeListener(h,g)}},onWindowUnload:function(i,h,g){var e=a.unloadEvent;if(!e){a.unloadEvent=e=new Ext.util.Event();a.addListener(c,"unload",a.fireUnload)}if(i){e.addListener(i,h,g)}},fireUnload:function(){try{d=c=undefined;var m,h,k,j,g;a.unloadEvent.fire();if(Ext.isGecko3){m=Ext.ComponentQuery.query("gridview");h=0;k=m.length;for(;h<k;h++){m[h].scrollToTop()}}g=Ext.cache;for(j in g){if(g.hasOwnProperty(j)){a.removeAll(j)}}}catch(l){}},removeUnloadListener:function(h,g){var e=a.unloadEvent;if(e){e.removeListener(h,g)}},useKeyDown:Ext.isWebKit?parseInt(navigator.userAgent.match(/AppleWebKit\/(\d+)/)[1],10)>=525:!((Ext.isGecko&&!Ext.isWindows)||Ext.isOpera),getKeyEvent:function(){return a.useKeyDown?"keydown":"keypress"}});if(!("addEventListener" in document)&&document.attachEvent){Ext.apply(a,{pollScroll:function(){var g=true;try{document.documentElement.doScroll("left")}catch(h){g=false}if(g&&document.body){a.onReadyEvent({type:"doScroll"})}else{a.scrollTimeout=setTimeout(a.pollScroll,20)}return g},scrollTimeout:null,readyStatesRe:/complete/i,checkReadyState:function(){var e=document.readyState;if(a.readyStatesRe.test(e)){a.onReadyEvent({type:e})}},bindReadyEvent:function(){var g=true;if(a.hasBoundOnReady){return}try{g=window.frameElement===undefined}catch(h){g=false}if(!g||!d.documentElement.doScroll){a.pollScroll=Ext.emptyFn}if(a.pollScroll()===true){return}if(d.readyState=="complete"){a.onReadyEvent({type:"already "+(d.readyState||"body")})}else{d.attachEvent("onreadystatechange",a.checkReadyState);window.attachEvent("onload",a.onReadyEvent);a.hasBoundOnReady=true}},onReadyEvent:function(g){if(g&&g.type){a.onReadyChain.push(g.type)}if(a.hasBoundOnReady){document.detachEvent("onreadystatechange",a.checkReadyState);window.detachEvent("onload",a.onReadyEvent)}if(Ext.isNumber(a.scrollTimeout)){clearTimeout(a.scrollTimeout);delete a.scrollTimeout}if(!Ext.isReady){a.fireDocReady()}},onReadyChain:[]})}Ext.onReady=function(h,g,e){Ext.Loader.onReady(h,g,true,e)};Ext.onDocumentReady=a.onDocumentReady;a.on=a.addListener;a.un=a.removeListener;Ext.onReady(b)};Ext.define("Ext.EventObjectImpl",{uses:["Ext.util.Point"],BACKSPACE:8,TAB:9,NUM_CENTER:12,ENTER:13,RETURN:13,SHIFT:16,CTRL:17,ALT:18,PAUSE:19,CAPS_LOCK:20,ESC:27,SPACE:32,PAGE_UP:33,PAGE_DOWN:34,END:35,HOME:36,LEFT:37,UP:38,RIGHT:39,DOWN:40,PRINT_SCREEN:44,INSERT:45,DELETE:46,ZERO:48,ONE:49,TWO:50,THREE:51,FOUR:52,FIVE:53,SIX:54,SEVEN:55,EIGHT:56,NINE:57,A:65,B:66,C:67,D:68,E:69,F:70,G:71,H:72,I:73,J:74,K:75,L:76,M:77,N:78,O:79,P:80,Q:81,R:82,S:83,T:84,U:85,V:86,W:87,X:88,Y:89,Z:90,CONTEXT_MENU:93,NUM_ZERO:96,NUM_ONE:97,NUM_TWO:98,NUM_THREE:99,NUM_FOUR:100,NUM_FIVE:101,NUM_SIX:102,NUM_SEVEN:103,NUM_EIGHT:104,NUM_NINE:105,NUM_MULTIPLY:106,NUM_PLUS:107,NUM_MINUS:109,NUM_PERIOD:110,NUM_DIVISION:111,F1:112,F2:113,F3:114,F4:115,F5:116,F6:117,F7:118,F8:119,F9:120,F10:121,F11:122,F12:123,WHEEL_SCALE:(function(){var a;if(Ext.isGecko){a=3}else{if(Ext.isMac){if(Ext.isSafari&&Ext.webKitVersion>=532){a=120}else{a=12}a*=3}else{a=120}}return a}()),clickRe:/(dbl)?click/,safariKeys:{3:13,63234:37,63235:39,63232:38,63233:40,63276:33,63277:34,63272:46,63273:36,63275:35},btnMap:Ext.isIE?{1:0,4:1,2:2}:{0:0,1:1,2:2},constructor:function(a,b){if(a){this.setEvent(a.browserEvent||a,b)}},setEvent:function(d,e){var c=this,b,a;if(d==c||(d&&d.browserEvent)){return d}c.browserEvent=d;if(d){b=d.button?c.btnMap[d.button]:(d.which?d.which-1:-1);if(c.clickRe.test(d.type)&&b==-1){b=0}a={type:d.type,button:b,shiftKey:d.shiftKey,ctrlKey:d.ctrlKey||d.metaKey||false,altKey:d.altKey,keyCode:d.keyCode,charCode:d.charCode,target:Ext.EventManager.getTarget(d),relatedTarget:Ext.EventManager.getRelatedTarget(d),currentTarget:d.currentTarget,xy:(e?c.getXY():null)}}else{a={button:-1,shiftKey:false,ctrlKey:false,altKey:false,keyCode:0,charCode:0,target:null,xy:[0,0]}}Ext.apply(c,a);return c},stopEvent:function(){this.stopPropagation();this.preventDefault()},preventDefault:function(){if(this.browserEvent){Ext.EventManager.preventDefault(this.browserEvent)}},stopPropagation:function(){var a=this.browserEvent;if(a){if(a.type=="mousedown"){Ext.EventManager.stoppedMouseDownEvent.fire(this)}Ext.EventManager.stopPropagation(a)}},getCharCode:function(){return this.charCode||this.keyCode},getKey:function(){return this.normalizeKey(this.keyCode||this.charCode)},normalizeKey:function(a){return Ext.isWebKit?(this.safariKeys[a]||a):a},getPageX:function(){return this.getX()},getPageY:function(){return this.getY()},getX:function(){return this.getXY()[0]},getY:function(){return this.getXY()[1]},getXY:function(){if(!this.xy){this.xy=Ext.EventManager.getPageXY(this.browserEvent)}return this.xy},getTarget:function(b,c,a){if(b){return Ext.fly(this.target).findParent(b,c,a)}return a?Ext.get(this.target):this.target},getRelatedTarget:function(b,c,a){if(b){return Ext.fly(this.relatedTarget).findParent(b,c,a)}return a?Ext.get(this.relatedTarget):this.relatedTarget},correctWheelDelta:function(c){var b=this.WHEEL_SCALE,a=Math.round(c/b);if(!a&&c){a=(c<0)?-1:1}return a},getWheelDeltas:function(){var d=this,c=d.browserEvent,b=0,a=0;if(Ext.isDefined(c.wheelDeltaX)){b=c.wheelDeltaX;a=c.wheelDeltaY}else{if(c.wheelDelta){a=c.wheelDelta}else{if(c.detail){a=-c.detail;if(a>100){a=3}else{if(a<-100){a=-3}}if(Ext.isDefined(c.axis)&&c.axis===c.HORIZONTAL_AXIS){b=a;a=0}}}}return{x:d.correctWheelDelta(b),y:d.correctWheelDelta(a)}},getWheelDelta:function(){var a=this.getWheelDeltas();return a.y},within:function(d,e,b){if(d){var c=e?this.getRelatedTarget():this.getTarget(),a;if(c){a=Ext.fly(d).contains(c);if(!a&&b){a=c==Ext.getDom(d)}return a}}return false},isNavKeyPress:function(){var b=this,a=this.normalizeKey(b.keyCode);return(a>=33&&a<=40)||a==b.RETURN||a==b.TAB||a==b.ESC},isSpecialKey:function(){var a=this.normalizeKey(this.keyCode);return(this.type=="keypress"&&this.ctrlKey)||this.isNavKeyPress()||(a==this.BACKSPACE)||(a>=16&&a<=20)||(a>=44&&a<=46)},getPoint:function(){var a=this.getXY();return new Ext.util.Point(a[0],a[1])},hasModifier:function(){return this.ctrlKey||this.altKey||this.shiftKey||this.metaKey},injectEvent:(function(){var d,e={},c;if(!Ext.isIE&&document.createEvent){d={createHtmlEvent:function(k,i,h,g){var j=k.createEvent("HTMLEvents");j.initEvent(i,h,g);return j},createMouseEvent:function(u,s,m,l,o,k,i,j,g,r,q,n,p){var h=u.createEvent("MouseEvents"),t=u.defaultView||window;if(h.initMouseEvent){h.initMouseEvent(s,m,l,t,o,k,i,k,i,j,g,r,q,n,p)}else{h=u.createEvent("UIEvents");h.initEvent(s,m,l);h.view=t;h.detail=o;h.screenX=k;h.screenY=i;h.clientX=k;h.clientY=i;h.ctrlKey=j;h.altKey=g;h.metaKey=q;h.shiftKey=r;h.button=n;h.relatedTarget=p}return h},createUIEvent:function(m,k,i,h,j){var l=m.createEvent("UIEvents"),g=m.defaultView||window;l.initUIEvent(k,i,h,g,j);return l},fireEvent:function(i,g,h){i.dispatchEvent(h)},fixTarget:function(g){if(g==window&&!g.dispatchEvent){return document}return g}}}else{if(document.createEventObject){c={0:1,1:4,2:2};d={createHtmlEvent:function(k,i,h,g){var j=k.createEventObject();j.bubbles=h;j.cancelable=g;return j},createMouseEvent:function(t,s,m,l,o,k,i,j,g,r,q,n,p){var h=t.createEventObject();h.bubbles=m;h.cancelable=l;h.detail=o;h.screenX=k;h.screenY=i;h.clientX=k;h.clientY=i;h.ctrlKey=j;h.altKey=g;h.shiftKey=r;h.metaKey=q;h.button=c[n]||n;h.relatedTarget=p;return h},createUIEvent:function(l,j,h,g,i){var k=l.createEventObject();k.bubbles=h;k.cancelable=g;return k},fireEvent:function(i,g,h){i.fireEvent("on"+g,h)},fixTarget:function(g){if(g==document){return document.documentElement}return g}}}}Ext.Object.each({load:[false,false],unload:[false,false],select:[true,false],change:[true,false],submit:[true,true],reset:[true,false],resize:[true,false],scroll:[true,false]},function(i,j){var h=j[0],g=j[1];e[i]=function(m,k){var l=d.createHtmlEvent(i,h,g);d.fireEvent(m,i,l)}});function b(i,h){var g=(i!="mousemove");return function(m,j){var l=j.getXY(),k=d.createMouseEvent(m.ownerDocument,i,true,g,h,l[0],l[1],j.ctrlKey,j.altKey,j.shiftKey,j.metaKey,j.button,j.relatedTarget);d.fireEvent(m,i,k)}}Ext.each(["click","dblclick","mousedown","mouseup","mouseover","mousemove","mouseout"],function(g){e[g]=b(g,1)});Ext.Object.each({focusin:[true,false],focusout:[true,false],activate:[true,true],focus:[false,false],blur:[false,false]},function(i,j){var h=j[0],g=j[1];e[i]=function(m,k){var l=d.createUIEvent(m.ownerDocument,i,h,g,1);d.fireEvent(m,i,l)}});if(!d){e={};d={fixTarget:function(g){return g}}}function a(h,g){}return function(j){var i=this,h=e[i.type]||a,g=j?(j.dom||j):i.getTarget();g=d.fixTarget(g);h(g,i)}}())},function(){Ext.EventObject=new Ext.EventObjectImpl()});Ext.define("Ext.dom.AbstractQuery",{select:function(k,b){var h=[],d,g,e,c,a;b=b||document;if(typeof b=="string"){b=document.getElementById(b)}k=k.split(",");for(g=0,c=k.length;g<c;g++){if(typeof k[g]=="string"){if(typeof k[g][0]=="@"){d=b.getAttributeNode(k[g].substring(1));h.push(d)}else{d=b.querySelectorAll(k[g]);for(e=0,a=d.length;e<a;e++){h.push(d[e])}}}}return h},selectNode:function(b,a){return this.select(b,a)[0]},is:function(a,b){if(typeof a=="string"){a=document.getElementById(a)}return this.select(b).indexOf(a)!==-1}});Ext.define("Ext.dom.AbstractHelper",{emptyTags:/^(?:br|frame|hr|img|input|link|meta|range|spacer|wbr|area|param|col)$/i,confRe:/(?:tag|children|cn|html|tpl|tplData)$/i,endRe:/end/i,attributeTransform:{cls:"class",htmlFor:"for"},closeTags:{},decamelizeName:(function(){var c=/([a-z])([A-Z])/g,b={};function a(d,g,e){return g+"-"+e.toLowerCase()}return function(d){return b[d]||(b[d]=d.replace(c,a))}}()),generateMarkup:function(d,c){var h=this,b,j,a,e,g;if(typeof d=="string"){c.push(d)}else{if(Ext.isArray(d)){for(e=0;e<d.length;e++){if(d[e]){h.generateMarkup(d[e],c)}}}else{a=d.tag||"div";c.push("<",a);for(b in d){if(d.hasOwnProperty(b)){j=d[b];if(!h.confRe.test(b)){if(typeof j=="object"){c.push(" ",b,'="');h.generateStyles(j,c).push('"')}else{c.push(" ",h.attributeTransform[b]||b,'="',j,'"')}}}}if(h.emptyTags.test(a)){c.push("/>")}else{c.push(">");if((j=d.tpl)){j.applyOut(d.tplData,c)}if((j=d.html)){c.push(j)}if((j=d.cn||d.children)){h.generateMarkup(j,c)}g=h.closeTags;c.push(g[a]||(g[a]="</"+a+">"))}}}return c},generateStyles:function(e,c){var b=c||[],d;for(d in e){if(e.hasOwnProperty(d)){b.push(this.decamelizeName(d),":",e[d],";")}}return c||b.join("")},markup:function(a){if(typeof a=="string"){return a}var b=this.generateMarkup(a,[]);return b.join("")},applyStyles:function(d,e){if(e){var b=0,a,c;d=Ext.fly(d);if(typeof e=="function"){e=e.call()}if(typeof e=="string"){e=Ext.util.Format.trim(e).split(/\s*(?::|;)\s*/);for(a=e.length;b<a;){d.setStyle(e[b++],e[b++])}}else{if(Ext.isObject(e)){d.setStyle(e)}}}},insertHtml:function(g,a,h){var e={},c,j,i,k,d,b;g=g.toLowerCase();e.beforebegin=["BeforeBegin","previousSibling"];e.afterend=["AfterEnd","nextSibling"];i=a.ownerDocument.createRange();j="setStart"+(this.endRe.test(g)?"After":"Before");if(e[g]){i[j](a);k=i.createContextualFragment(h);a.parentNode.insertBefore(k,g=="beforebegin"?a:a.nextSibling);return a[(g=="beforebegin"?"previous":"next")+"Sibling"]}else{d=(g=="afterbegin"?"first":"last")+"Child";if(a.firstChild){i[j](a[d]);k=i.createContextualFragment(h);if(g=="afterbegin"){a.insertBefore(k,a.firstChild)}else{a.appendChild(k)}}else{a.innerHTML=h}return a[d]}throw'Illegal insertion point -> "'+g+'"'},insertBefore:function(a,c,b){return this.doInsert(a,c,b,"beforebegin")},insertAfter:function(a,c,b){return this.doInsert(a,c,b,"afterend","nextSibling")},insertFirst:function(a,c,b){return this.doInsert(a,c,b,"afterbegin","firstChild")},append:function(a,c,b){return this.doInsert(a,c,b,"beforeend","",true)},overwrite:function(a,c,b){a=Ext.getDom(a);a.innerHTML=this.markup(c);return b?Ext.get(a.firstChild):a.firstChild},doInsert:function(d,g,e,h,c,a){var b=this.insertHtml(h,Ext.getDom(d),this.markup(g));return e?Ext.get(b,true):b}});(function(){var a=window.document,b=/^\s+|\s+$/g,c=/\s/;if(!Ext.cache){Ext.cache={}}Ext.define("Ext.dom.AbstractElement",{inheritableStatics:{get:function(e){var g=this,h=Ext.dom.Element,d,j,i,k;if(!e){return null}if(typeof e=="string"){if(e==Ext.windowId){return h.get(window)}else{if(e==Ext.documentId){return h.get(a)}}d=Ext.cache[e];if(d&&d.skipGarbageCollection){j=d.el;return j}if(!(i=a.getElementById(e))){return null}if(d&&d.el){j=Ext.updateCacheEntry(d,i).el}else{j=new h(i,!!d)}return j}else{if(e.tagName){if(!(k=e.id)){k=Ext.id(e)}d=Ext.cache[k];if(d&&d.el){j=Ext.updateCacheEntry(d,e).el}else{j=new h(e,!!d)}return j}else{if(e instanceof g){if(e!=g.docEl&&e!=g.winEl){k=e.id;d=Ext.cache[k];if(d){Ext.updateCacheEntry(d,a.getElementById(k)||e.dom)}}return e}else{if(e.isComposite){return e}else{if(Ext.isArray(e)){return g.select(e)}else{if(e===a){if(!g.docEl){g.docEl=Ext.Object.chain(h.prototype);g.docEl.dom=a;g.docEl.id=Ext.id(a);g.addToCache(g.docEl)}return g.docEl}else{if(e===window){if(!g.winEl){g.winEl=Ext.Object.chain(h.prototype);g.winEl.dom=window;g.winEl.id=Ext.id(window);g.addToCache(g.winEl)}return g.winEl}}}}}}}return null},addToCache:function(d,e){if(d){Ext.addCacheEntry(e,d)}return d},addMethods:function(){this.override.apply(this,arguments)},mergeClsList:function(){var n,m={},k,d,g,l,e,o=[],h=false;for(k=0,d=arguments.length;k<d;k++){n=arguments[k];if(Ext.isString(n)){n=n.replace(b,"").split(c)}if(n){for(g=0,l=n.length;g<l;g++){e=n[g];if(!m[e]){if(k){h=true}m[e]=true}}}}for(e in m){o.push(e)}o.changed=h;return o},removeCls:function(g,l){var e={},h,k,j,d=[],m=false;if(g){if(Ext.isString(g)){g=g.replace(b,"").split(c)}for(h=0,k=g.length;h<k;h++){e[g[h]]=true}}if(l){if(Ext.isString(l)){l=l.split(c)}for(h=0,k=l.length;h<k;h++){j=l[h];if(e[j]){m=true;delete e[j]}}}for(j in e){d.push(j)}d.changed=m;return d},VISIBILITY:1,DISPLAY:2,OFFSETS:3,ASCLASS:4},constructor:function(d,e){var g=this,h=typeof d=="string"?a.getElementById(d):d,i;if(!h){return null}i=h.id;if(!e&&i&&Ext.cache[i]){return Ext.cache[i].el}g.dom=h;g.id=i||Ext.id(h);g.self.addToCache(g)},set:function(i,e){var g=this.dom,d,h;for(d in i){if(i.hasOwnProperty(d)){h=i[d];if(d=="style"){this.applyStyles(h)}else{if(d=="cls"){g.className=h}else{if(e!==false){if(h===undefined){g.removeAttribute(d)}else{g.setAttribute(d,h)}}else{g[d]=h}}}}}return this},defaultUnit:"px",is:function(d){return Ext.DomQuery.is(this.dom,d)},getValue:function(d){var e=this.dom.value;return d?parseInt(e,10):e},remove:function(){var d=this,e=d.dom;if(e){Ext.removeNode(e);delete d.dom}},contains:function(d){if(!d){return false}var e=this,g=d.dom||d;return(g===e.dom)||Ext.dom.AbstractElement.isAncestor(e.dom,g)},getAttribute:function(d,e){var g=this.dom;return g.getAttributeNS(e,d)||g.getAttribute(e+":"+d)||g.getAttribute(d)||g[d]},update:function(d){if(this.dom){this.dom.innerHTML=d}return this},setHTML:function(d){if(this.dom){this.dom.innerHTML=d}return this},getHTML:function(){return this.dom?this.dom.innerHTML:""},hide:function(){this.setVisible(false);return this},show:function(){this.setVisible(true);return this},setVisible:function(j,d){var e=this,i=e.self,h=e.getVisibilityMode(),g=Ext.baseCSSPrefix;switch(h){case i.VISIBILITY:e.removeCls([g+"hidden-display",g+"hidden-offsets"]);e[j?"removeCls":"addCls"](g+"hidden-visibility");break;case i.DISPLAY:e.removeCls([g+"hidden-visibility",g+"hidden-offsets"]);e[j?"removeCls":"addCls"](g+"hidden-display");break;case i.OFFSETS:e.removeCls([g+"hidden-visibility",g+"hidden-display"]);e[j?"removeCls":"addCls"](g+"hidden-offsets");break}return e},getVisibilityMode:function(){var e=(this.$cache||this.getCache()).data,d=e.visibilityMode;if(d===undefined){e.visibilityMode=d=this.self.DISPLAY}return d},setVisibilityMode:function(d){(this.$cache||this.getCache()).data.visibilityMode=d;return this},getCache:function(){var d=this,e=d.dom.id||Ext.id(d.dom);d.$cache=Ext.cache[e]||Ext.addCacheEntry(e,null,d.dom);return d.$cache}},function(){var d=this;Ext.getDetachedBody=function(){var e=d.detachedBodyEl;if(!e){e=a.createElement("div");d.detachedBodyEl=e=new d.Fly(e);e.isDetachedBody=true}return e};Ext.getElementById=function(h){var g=a.getElementById(h),e;if(!g&&(e=d.detachedBodyEl)){g=e.dom.querySelector("#"+Ext.escapeId(h))}return g};Ext.get=function(e){return Ext.dom.Element.get(e)};this.addStatics({Fly:new Ext.Class({extend:d,isFly:true,constructor:function(e){this.dom=e},attach:function(e){this.dom=e;this.$cache=e.id?Ext.cache[e.id]:null;return this}}),_flyweights:{},fly:function(i,g){var h=null,e=d._flyweights;g=g||"_global";i=Ext.getDom(i);if(i){h=e[g]||(e[g]=new d.Fly());h.dom=i;h.$cache=i.id?Ext.cache[i.id]:null}return h}});Ext.fly=function(){return d.fly.apply(d,arguments)};(function(e){e.destroy=e.remove;if(a.querySelector){e.getById=function(i,g){var h=a.getElementById(i)||this.dom.querySelector("#"+Ext.escapeId(i));return g?h:(h?Ext.get(h):null)}}else{e.getById=function(i,g){var h=a.getElementById(i);return g?h:(h?Ext.get(h):null)}}}(this.prototype))})}());Ext.dom.AbstractElement.addInheritableStatics({unitRe:/\d+(px|em|%|en|ex|pt|in|cm|mm|pc)$/i,camelRe:/(-[a-z])/gi,cssRe:/([a-z0-9\-]+)\s*:\s*([^;\s]+(?:\s*[^;\s]+)*);?/gi,opacityRe:/alpha\(opacity=(.*)\)/i,propertyCache:{},defaultUnit:"px",borders:{l:"border-left-width",r:"border-right-width",t:"border-top-width",b:"border-bottom-width"},paddings:{l:"padding-left",r:"padding-right",t:"padding-top",b:"padding-bottom"},margins:{l:"margin-left",r:"margin-right",t:"margin-top",b:"margin-bottom"},addUnits:function(b,a){if(typeof b=="number"){return b+(a||this.defaultUnit||"px")}if(b===""||b=="auto"||b===undefined||b===null){return b||""}if(!this.unitRe.test(b)){return b||""}return b},isAncestor:function(b,d){var a=false;b=Ext.getDom(b);d=Ext.getDom(d);if(b&&d){if(b.contains){return b.contains(d)}else{if(b.compareDocumentPosition){return !!(b.compareDocumentPosition(d)&16)}else{while((d=d.parentNode)){a=d==b||a}}}}return a},parseBox:function(b){if(typeof b!="string"){b=b.toString()}var c=b.split(" "),a=c.length;if(a==1){c[1]=c[2]=c[3]=c[0]}else{if(a==2){c[2]=c[0];c[3]=c[1]}else{if(a==3){c[3]=c[1]}}}return{top:parseFloat(c[0])||0,right:parseFloat(c[1])||0,bottom:parseFloat(c[2])||0,left:parseFloat(c[3])||0}},unitizeBox:function(g,e){var d=this.addUnits,c=this.parseBox(g);return d(c.top,e)+" "+d(c.right,e)+" "+d(c.bottom,e)+" "+d(c.left,e)},camelReplaceFn:function(b,c){return c.charAt(1).toUpperCase()},normalize:function(a){if(a=="float"){a=Ext.supports.Float?"cssFloat":"styleFloat"}return this.propertyCache[a]||(this.propertyCache[a]=a.replace(this.camelRe,this.camelReplaceFn))},getDocumentHeight:function(){return Math.max(!Ext.isStrict?document.body.scrollHeight:document.documentElement.scrollHeight,this.getViewportHeight())},getDocumentWidth:function(){return Math.max(!Ext.isStrict?document.body.scrollWidth:document.documentElement.scrollWidth,this.getViewportWidth())},getViewportHeight:function(){return window.innerHeight},getViewportWidth:function(){return window.innerWidth},getViewSize:function(){return{width:window.innerWidth,height:window.innerHeight}},getOrientation:function(){if(Ext.supports.OrientationChange){return(window.orientation==0)?"portrait":"landscape"}return(window.innerHeight>window.innerWidth)?"portrait":"landscape"},fromPoint:function(a,b){return Ext.get(document.elementFromPoint(a,b))},parseStyles:function(c){var a={},b=this.cssRe,d;if(c){b.lastIndex=0;while((d=b.exec(c))){a[d[1]]=d[2]}}return a}});(function(){var g=document,a=Ext.dom.AbstractElement,e=null,d=g.compatMode=="CSS1Compat",c,b=function(i){if(!c){c=new a.Fly()}c.attach(i);return c};if(!("activeElement" in g)&&g.addEventListener){g.addEventListener("focus",function(i){if(i&&i.target){e=(i.target==g)?null:i.target}},true)}function h(j,k,i){return function(){j.selectionStart=k;j.selectionEnd=i}}a.addInheritableStatics({getActiveElement:function(){return g.activeElement||e},getRightMarginFixCleaner:function(n){var k=Ext.supports,l=k.DisplayChangeInputSelectionBug,m=k.DisplayChangeTextAreaSelectionBug,o,i,p,j;if(l||m){o=g.activeElement||e;i=o&&o.tagName;if((m&&i=="TEXTAREA")||(l&&i=="INPUT"&&o.type=="text")){if(Ext.dom.Element.isAncestor(n,o)){p=o.selectionStart;j=o.selectionEnd;if(Ext.isNumber(p)&&Ext.isNumber(j)){return h(o,p,j)}}}}return Ext.emptyFn},getViewWidth:function(i){return i?Ext.dom.Element.getDocumentWidth():Ext.dom.Element.getViewportWidth()},getViewHeight:function(i){return i?Ext.dom.Element.getDocumentHeight():Ext.dom.Element.getViewportHeight()},getDocumentHeight:function(){return Math.max(!d?g.body.scrollHeight:g.documentElement.scrollHeight,Ext.dom.Element.getViewportHeight())},getDocumentWidth:function(){return Math.max(!d?g.body.scrollWidth:g.documentElement.scrollWidth,Ext.dom.Element.getViewportWidth())},getViewportHeight:function(){return Ext.isIE?(Ext.isStrict?g.documentElement.clientHeight:g.body.clientHeight):self.innerHeight},getViewportWidth:function(){return(!Ext.isStrict&&!Ext.isOpera)?g.body.clientWidth:Ext.isIE?g.documentElement.clientWidth:self.innerWidth},getY:function(i){return Ext.dom.Element.getXY(i)[1]},getX:function(i){return Ext.dom.Element.getXY(i)[0]},getXY:function(k){var n=g.body,j=g.documentElement,i=0,l=0,o=[0,0],r=Math.round,m,q;k=Ext.getDom(k);if(k!=g&&k!=n){if(Ext.isIE){try{m=k.getBoundingClientRect();l=j.clientTop||n.clientTop;i=j.clientLeft||n.clientLeft}catch(p){m={left:0,top:0}}}else{m=k.getBoundingClientRect()}q=b(document).getScroll();o=[r(m.left+q.left-i),r(m.top+q.top-l)]}return o},setXY:function(j,k){(j=Ext.fly(j,"_setXY")).position();var l=j.translatePoints(k),i=j.dom.style,m;for(m in l){if(!isNaN(l[m])){i[m]=l[m]+"px"}}},setX:function(j,i){Ext.dom.Element.setXY(j,[i,false])},setY:function(i,j){Ext.dom.Element.setXY(i,[false,j])},serializeForm:function(k){var l=k.elements||(document.forms[k]||Ext.getDom(k)).elements,v=false,u=encodeURIComponent,p="",n=l.length,q,i,t,x,w,r,m,s,j;for(r=0;r<n;r++){q=l[r];i=q.name;t=q.type;x=q.options;if(!q.disabled&&i){if(/select-(one|multiple)/i.test(t)){s=x.length;for(m=0;m<s;m++){j=x[m];if(j.selected){w=j.hasAttribute?j.hasAttribute("value"):j.getAttributeNode("value").specified;p+=Ext.String.format("{0}={1}&",u(i),u(w?j.value:j.text))}}}else{if(!(/file|undefined|reset|button/i.test(t))){if(!(/radio|checkbox/i.test(t)&&!q.checked)&&!(t=="submit"&&v)){p+=u(i)+"="+u(q.value)+"&";v=/submit/i.test(t)}}}}}return p.substr(0,p.length-1)}})}());Ext.dom.AbstractElement.override({getAnchorXY:function(g,k,n){g=(g||"tl").toLowerCase();n=n||{};var j=this,a=j.dom==document.body||j.dom==document,b=n.width||a?window.innerWidth:j.getWidth(),l=n.height||a?window.innerHeight:j.getHeight(),m,c=Math.round,d=j.getXY(),i=a?0:!k?d[0]:0,h=a?0:!k?d[1]:0,e={c:[c(b*0.5),c(l*0.5)],t:[c(b*0.5),0],l:[0,c(l*0.5)],r:[b,c(l*0.5)],b:[c(b*0.5),l],tl:[0,0],bl:[0,l],br:[b,l],tr:[b,0]};m=e[g];return[m[0]+i,m[1]+h]},alignToRe:/^([a-z]+)-([a-z]+)(\?)?$/,getAlignToXY:function(e,z,i,s){s=!!s;e=Ext.get(e);i=i||[0,0];if(!z||z=="?"){z="tl-bl?"}else{if(!(/-/).test(z)&&z!==""){z="tl-"+z}}z=z.toLowerCase();var v=this,d=z.match(this.alignToRe),n=window.innerWidth,u=window.innerHeight,c="",b="",A,w,m,l,q,o,g,a,k,j,r,p,h,t;if(!d){throw"Element.alignTo with an invalid alignment "+z}c=d[1];b=d[2];t=!!d[3];A=v.getAnchorXY(c,true);w=e.getAnchorXY(b,s);m=w[0]-A[0]+i[0];l=w[1]-A[1]+i[1];if(t){r=v.getWidth();p=v.getHeight();h=e.getPageBox();a=c.charAt(0);g=c.charAt(c.length-1);j=b.charAt(0);k=b.charAt(b.length-1);o=((a=="t"&&j=="b")||(a=="b"&&j=="t"));q=((g=="r"&&k=="l")||(g=="l"&&k=="r"));if(m+r>n){m=q?h.left-r:n-r}if(m<0){m=q?h.right:0}if(l+p>u){l=o?h.top-p:u-p}if(l<0){l=o?h.bottom:0}}return[m,l]},getAnchor:function(){var b=(this.$cache||this.getCache()).data,a;if(!this.dom){return}a=b._anchor;if(!a){a=b._anchor={}}return a},adjustForConstraints:function(c,b){var a=this.getConstrainVector(b,c);if(a){c[0]+=a[0];c[1]+=a[1]}return c}});Ext.dom.AbstractElement.addMethods({appendChild:function(a){return Ext.get(a).appendTo(this)},appendTo:function(a){Ext.getDom(a).appendChild(this.dom);return this},insertBefore:function(a){a=Ext.getDom(a);a.parentNode.insertBefore(this.dom,a);return this},insertAfter:function(a){a=Ext.getDom(a);a.parentNode.insertBefore(this.dom,a.nextSibling);return this},insertFirst:function(b,a){b=b||{};if(b.nodeType||b.dom||typeof b=="string"){b=Ext.getDom(b);this.dom.insertBefore(b,this.dom.firstChild);return !a?Ext.get(b):b}else{return this.createChild(b,this.dom.firstChild,a)}},insertSibling:function(b,g,j){var i=this,k=(g||"before").toLowerCase()=="after",d,a,c,h;if(Ext.isArray(b)){a=i;c=b.length;for(h=0;h<c;h++){d=Ext.fly(a,"_internal").insertSibling(b[h],g,j);if(k){a=d}}return d}b=b||{};if(b.nodeType||b.dom){d=i.dom.parentNode.insertBefore(Ext.getDom(b),k?i.dom.nextSibling:i.dom);if(!j){d=Ext.get(d)}}else{if(k&&!i.dom.nextSibling){d=Ext.core.DomHelper.append(i.dom.parentNode,b,!j)}else{d=Ext.core.DomHelper[k?"insertAfter":"insertBefore"](i.dom,b,!j)}}return d},replace:function(a){a=Ext.get(a);this.insertBefore(a);a.remove();return this},replaceWith:function(a){var b=this;if(a.nodeType||a.dom||typeof a=="string"){a=Ext.get(a);b.dom.parentNode.insertBefore(a,b.dom)}else{a=Ext.core.DomHelper.insertBefore(b.dom,a)}delete Ext.cache[b.id];Ext.removeNode(b.dom);b.id=Ext.id(b.dom=a);Ext.dom.AbstractElement.addToCache(b.isFlyweight?new Ext.dom.AbstractElement(b.dom):b);return b},createChild:function(b,a,c){b=b||{tag:"div"};if(a){return Ext.core.DomHelper.insertBefore(a,b,c!==true)}else{return Ext.core.DomHelper[!this.dom.firstChild?"insertFirst":"append"](this.dom,b,c!==true)}},wrap:function(b,c,a){var e=Ext.core.DomHelper.insertBefore(this.dom,b||{tag:"div"},true),d=e;if(a){d=Ext.DomQuery.selectNode(a,e.dom)}d.appendChild(this.dom);return c?e.dom:e},insertHtml:function(b,c,a){var d=Ext.core.DomHelper.insertHtml(b,this.dom,c);return a?Ext.get(d):d}});(function(){var a=Ext.dom.AbstractElement;a.override({getX:function(b){return this.getXY(b)[0]},getY:function(b){return this.getXY(b)[1]},getXY:function(){var b=window.webkitConvertPointFromNodeToPage(this.dom,new WebKitPoint(0,0));return[b.x,b.y]},getOffsetsTo:function(b){var d=this.getXY(),c=Ext.fly(b,"_internal").getXY();return[d[0]-c[0],d[1]-c[1]]},setX:function(b){return this.setXY([b,this.getY()])},setY:function(b){return this.setXY([this.getX(),b])},setLeft:function(b){this.setStyle("left",a.addUnits(b));return this},setTop:function(b){this.setStyle("top",a.addUnits(b));return this},setRight:function(b){this.setStyle("right",a.addUnits(b));return this},setBottom:function(b){this.setStyle("bottom",a.addUnits(b));return this},setXY:function(g){var c=this,e,b,d;if(arguments.length>1){g=[g,arguments[1]]}e=c.translatePoints(g);b=c.dom.style;for(d in e){if(!e.hasOwnProperty(d)){continue}if(!isNaN(e[d])){b[d]=e[d]+"px"}}return c},getLeft:function(b){return parseInt(this.getStyle("left"),10)||0},getRight:function(b){return parseInt(this.getStyle("right"),10)||0},getTop:function(b){return parseInt(this.getStyle("top"),10)||0},getBottom:function(b){return parseInt(this.getStyle("bottom"),10)||0},translatePoints:function(b,i){i=isNaN(b[1])?i:b[1];b=isNaN(b[0])?b:b[0];var e=this,g=e.isStyle("position","relative"),h=e.getXY(),c=parseInt(e.getStyle("left"),10),d=parseInt(e.getStyle("top"),10);c=!isNaN(c)?c:(g?0:e.dom.offsetLeft);d=!isNaN(d)?d:(g?0:e.dom.offsetTop);return{left:(b-h[0]+c),top:(i-h[1]+d)}},setBox:function(e){var d=this,c=e.width,b=e.height,h=e.top,g=e.left;if(g!==undefined){d.setLeft(g)}if(h!==undefined){d.setTop(h)}if(c!==undefined){d.setWidth(c)}if(b!==undefined){d.setHeight(b)}return this},getBox:function(i,m){var j=this,g=j.dom,d=g.offsetWidth,n=g.offsetHeight,p,h,e,c,o,k;if(!m){p=j.getXY()}else{if(i){p=[0,0]}else{p=[parseInt(j.getStyle("left"),10)||0,parseInt(j.getStyle("top"),10)||0]}}if(!i){h={x:p[0],y:p[1],0:p[0],1:p[1],width:d,height:n}}else{e=j.getBorderWidth.call(j,"l")+j.getPadding.call(j,"l");c=j.getBorderWidth.call(j,"r")+j.getPadding.call(j,"r");o=j.getBorderWidth.call(j,"t")+j.getPadding.call(j,"t");k=j.getBorderWidth.call(j,"b")+j.getPadding.call(j,"b");h={x:p[0]+e,y:p[1]+o,0:p[0]+e,1:p[1]+o,width:d-(e+c),height:n-(o+k)}}h.left=h.x;h.top=h.y;h.right=h.x+h.width;h.bottom=h.y+h.height;return h},getPageBox:function(g){var j=this,d=j.dom,m=d.offsetWidth,i=d.offsetHeight,o=j.getXY(),n=o[1],c=o[0]+m,k=o[1]+i,e=o[0];if(!d){return new Ext.util.Region()}if(g){return new Ext.util.Region(n,c,k,e)}else{return{left:e,top:n,width:m,height:i,right:c,bottom:k}}}})}());(function(){var q=Ext.dom.AbstractElement,o=document.defaultView,n=Ext.Array,m=/^\s+|\s+$/g,b=/\w/g,p=/\s+/,t=/^(?:transparent|(?:rgba[(](?:\s*\d+\s*[,]){3}\s*0\s*[)]))$/i,h=Ext.supports.ClassList,e="padding",d="margin",s="border",k="-left",r="-right",l="-top",c="-bottom",i="-width",j={l:s+k+i,r:s+r+i,t:s+l+i,b:s+c+i},g={l:e+k,r:e+r,t:e+l,b:e+c},a={l:d+k,r:d+r,t:d+l,b:d+c};q.override({styleHooks:{},addStyles:function(B,A){var w=0,z=(B||"").match(b),y,u=z.length,x,v=[];if(u==1){w=Math.abs(parseFloat(this.getStyle(A[z[0]]))||0)}else{if(u){for(y=0;y<u;y++){x=z[y];v.push(A[x])}v=this.getStyle(v);for(y=0;y<u;y++){x=z[y];w+=Math.abs(parseFloat(v[A[x]])||0)}}}return w},addCls:h?function(x){var z=this,B=z.dom,A,y,w,u,v;if(typeof(x)=="string"){x=x.replace(m,"").split(p)}if(B&&x&&!!(u=x.length)){if(!B.className){B.className=x.join(" ")}else{A=B.classList;for(w=0;w<u;++w){v=x[w];if(v){if(!A.contains(v)){if(y){y.push(v)}else{y=B.className.replace(m,"");y=y?[y,v]:[v]}}}}if(y){B.className=y.join(" ")}}}return z}:function(v){var w=this,y=w.dom,x,u;if(y&&v&&v.length){u=Ext.Element.mergeClsList(y.className,v);if(u.changed){y.className=u.join(" ")}}return w},removeCls:function(w){var x=this,y=x.dom,u,v;if(typeof(w)=="string"){w=w.replace(m,"").split(p)}if(y&&y.className&&w&&!!(u=w.length)){if(u==1&&h){if(w[0]){y.classList.remove(w[0])}}else{v=Ext.Element.removeCls(y.className,w);if(v.changed){y.className=v.join(" ")}}}return x},radioCls:function(y){var z=this.dom.parentNode.childNodes,w,x,u;y=Ext.isArray(y)?y:[y];for(x=0,u=z.length;x<u;x++){w=z[x];if(w&&w.nodeType==1){Ext.fly(w,"_internal").removeCls(y)}}return this.addCls(y)},toggleCls:h?function(u){var v=this,w=v.dom;if(w){u=u.replace(m,"");if(u){w.classList.toggle(u)}}return v}:function(u){var v=this;return v.hasCls(u)?v.removeCls(u):v.addCls(u)},hasCls:h?function(u){var v=this.dom;return(v&&u)?v.classList.contains(u):false}:function(u){var v=this.dom;return v?u&&(" "+v.className+" ").indexOf(" "+u+" ")!=-1:false},replaceCls:function(v,u){return this.removeCls(v).addCls(u)},isStyle:function(u,v){return this.getStyle(u)==v},getStyle:function(G,B){var C=this,x=C.dom,J=typeof G!="string",H=C.styleHooks,v=G,D=v,A=1,z,I,F,E,w,u,y;if(J){F={};v=D[0];y=0;if(!(A=D.length)){return F}}if(!x||x.documentElement){return F||""}z=x.style;if(B){u=z}else{u=x.ownerDocument.defaultView.getComputedStyle(x,null);if(!u){B=true;u=z}}do{E=H[v];if(!E){H[v]=E={name:q.normalize(v)}}if(E.get){w=E.get(x,C,B,u)}else{I=E.name;w=u[I]}if(!J){return w}F[v]=w;v=D[++y]}while(y<A);return F},getStyles:function(){var v=Ext.Array.slice(arguments),u=v.length,w;if(u&&typeof v[u-1]=="boolean"){w=v.pop()}return this.getStyle(v,w)},isTransparent:function(v){var u=this.getStyle(v);return u?t.test(u):false},setStyle:function(B,z){var x=this,A=x.dom,u=x.styleHooks,w=A.style,v=B,y;if(typeof v=="string"){y=u[v];if(!y){u[v]=y={name:q.normalize(v)}}z=(z==null)?"":z;if(y.set){y.set(A,z,x)}else{w[y.name]=z}if(y.afterSet){y.afterSet(A,z,x)}}else{for(v in B){if(B.hasOwnProperty(v)){y=u[v];if(!y){u[v]=y={name:q.normalize(v)}}z=B[v];z=(z==null)?"":z;if(y.set){y.set(A,z,x)}else{w[y.name]=z}if(y.afterSet){y.afterSet(A,z,x)}}}}return x},getHeight:function(v){var w=this.dom,u=v?(w.clientHeight-this.getPadding("tb")):w.offsetHeight;return u>0?u:0},getWidth:function(u){var w=this.dom,v=u?(w.clientWidth-this.getPadding("lr")):w.offsetWidth;return v>0?v:0},setWidth:function(u){var v=this;v.dom.style.width=q.addUnits(u);return v},setHeight:function(u){var v=this;v.dom.style.height=q.addUnits(u);return v},getBorderWidth:function(u){return this.addStyles(u,j)},getPadding:function(u){return this.addStyles(u,g)},margins:a,applyStyles:function(w){if(w){var v,u,x=this.dom;if(typeof w=="function"){w=w.call()}if(typeof w=="string"){w=Ext.util.Format.trim(w).split(/\s*(?::|;)\s*/);for(v=0,u=w.length;v<u;){x.style[q.normalize(w[v++])]=w[v++]}}else{if(typeof w=="object"){this.setStyle(w)}}}},setSize:function(w,u){var x=this,v=x.dom.style;if(Ext.isObject(w)){u=w.height;w=w.width}v.width=q.addUnits(w);v.height=q.addUnits(u);return x},getViewSize:function(){var u=document,v=this.dom;if(v==u||v==u.body){return{width:q.getViewportWidth(),height:q.getViewportHeight()}}else{return{width:v.clientWidth,height:v.clientHeight}}},getSize:function(v){var u=this.dom;return{width:Math.max(0,v?(u.clientWidth-this.getPadding("lr")):u.offsetWidth),height:Math.max(0,v?(u.clientHeight-this.getPadding("tb")):u.offsetHeight)}},repaint:function(){var u=this.dom;this.addCls(Ext.baseCSSPrefix+"repaint");setTimeout(function(){Ext.fly(u).removeCls(Ext.baseCSSPrefix+"repaint")},1);return this},getMargin:function(v){var w=this,y={t:"top",l:"left",r:"right",b:"bottom"},u,z,x;if(!v){x=[];for(u in w.margins){if(w.margins.hasOwnProperty(u)){x.push(w.margins[u])}}z=w.getStyle(x);if(z&&typeof z=="object"){for(u in w.margins){if(w.margins.hasOwnProperty(u)){z[y[u]]=parseFloat(z[w.margins[u]])||0}}}return z}else{return w.addStyles.call(w,v,w.margins)}},mask:function(v,z,D){var A=this,w=A.dom,x=(A.$cache||A.getCache()).data,u=x.mask,E,C,B="",y=Ext.baseCSSPrefix;A.addCls(y+"masked");if(A.getStyle("position")=="static"){A.addCls(y+"masked-relative")}if(u){u.remove()}if(z&&typeof z=="string"){B=" "+z}else{B=" "+y+"mask-gray"}E=A.createChild({cls:y+"mask"+((D!==false)?"":(" "+y+"mask-gray")),html:v?('<div class="'+(z||(y+"mask-message"))+'">'+v+"</div>"):""});C=A.getSize();x.mask=E;if(w===document.body){C.height=window.innerHeight;if(A.orientationHandler){Ext.EventManager.unOrientationChange(A.orientationHandler,A)}A.orientationHandler=function(){C=A.getSize();C.height=window.innerHeight;E.setSize(C)};Ext.EventManager.onOrientationChange(A.orientationHandler,A)}E.setSize(C);if(Ext.is.iPad){Ext.repaint()}},unmask:function(){var v=this,x=(v.$cache||v.getCache()).data,u=x.mask,w=Ext.baseCSSPrefix;if(u){u.remove();delete x.mask}v.removeCls([w+"masked",w+"masked-relative"]);if(v.dom===document.body){Ext.EventManager.unOrientationChange(v.orientationHandler,v);delete v.orientationHandler}}});q.populateStyleMap=function(B,u){var A=["margin-","padding-","border-width-"],z=["before","after"],w,y,v,x;for(w=A.length;w--;){for(x=2;x--;){y=A[w]+z[x];B[q.normalize(y)]=B[y]={name:q.normalize(A[w]+u[x])}}}};Ext.onReady(function(){var C=Ext.supports,u,A,y,v,B;function z(H,E,G,D){var F=D[this.name]||"";return t.test(F)?"transparent":F}function x(J,G,I,F){var D=F.marginRight,E,H;if(D!="0px"){E=J.style;H=E.display;E.display="inline-block";D=(I?F:J.ownerDocument.defaultView.getComputedStyle(J,null)).marginRight;E.display=H}return D}function w(K,H,J,G){var D=G.marginRight,F,E,I;if(D!="0px"){F=K.style;E=q.getRightMarginFixCleaner(K);I=F.display;F.display="inline-block";D=(J?G:K.ownerDocument.defaultView.getComputedStyle(K,"")).marginRight;F.display=I;E()}return D}u=q.prototype.styleHooks;q.populateStyleMap(u,["left","right"]);if(C.init){C.init()}if(!C.RightMargin){u.marginRight=u["margin-right"]={name:"marginRight",get:(C.DisplayChangeInputSelectionBug||C.DisplayChangeTextAreaSelectionBug)?w:x}}if(!C.TransparentColor){A=["background-color","border-color","color","outline-color"];for(y=A.length;y--;){v=A[y];B=q.normalize(v);u[v]=u[B]={name:B,get:z}}}})}());Ext.dom.AbstractElement.override({findParent:function(h,b,a){var e=this.dom,c=document.documentElement,g=0,d;b=b||50;if(isNaN(b)){d=Ext.getDom(b);b=Number.MAX_VALUE}while(e&&e.nodeType==1&&g<b&&e!=c&&e!=d){if(Ext.DomQuery.is(e,h)){return a?Ext.get(e):e}g++;e=e.parentNode}return null},findParentNode:function(d,b,a){var c=Ext.fly(this.dom.parentNode,"_internal");return c?c.findParent(d,b,a):null},up:function(b,a){return this.findParentNode(b,a,true)},select:function(a,b){return Ext.dom.Element.select(a,this.dom,b)},query:function(a){return Ext.DomQuery.select(a,this.dom)},down:function(a,b){var c=Ext.DomQuery.selectNode(a,this.dom);return b?c:Ext.get(c)},child:function(a,b){var d,c=this,e;e=Ext.id(c.dom);e=Ext.escapeId(e);d=Ext.DomQuery.selectNode("#"+e+" > "+a,c.dom);return b?d:Ext.get(d)},parent:function(a,b){return this.matchNode("parentNode","parentNode",a,b)},next:function(a,b){return this.matchNode("nextSibling","nextSibling",a,b)},prev:function(a,b){return this.matchNode("previousSibling","previousSibling",a,b)},first:function(a,b){return this.matchNode("nextSibling","firstChild",a,b)},last:function(a,b){return this.matchNode("previousSibling","lastChild",a,b)},matchNode:function(b,e,a,c){if(!this.dom){return null}var d=this.dom[e];while(d){if(d.nodeType==1&&(!a||Ext.DomQuery.is(d,a))){return !c?Ext.get(d):d}d=d[b]}return null},isAncestor:function(a){return this.self.isAncestor.call(this.self,this.dom,a)}});(function(){var b="afterbegin",i="afterend",a="beforebegin",o="beforeend",l="<table>",h="</table>",c=l+"<tbody>",n="</tbody>"+h,k=c+"<tr>",e="</tr>"+n,p=document.createElement("div"),m=["BeforeBegin","previousSibling"],j=["AfterEnd","nextSibling"],d={beforebegin:m,afterend:j},g={beforebegin:m,afterend:j,afterbegin:["AfterBegin","firstChild"],beforeend:["BeforeEnd","lastChild"]};Ext.define("Ext.dom.Helper",{extend:"Ext.dom.AbstractHelper",requires:["Ext.dom.AbstractElement"],tableRe:/^table|tbody|tr|td$/i,tableElRe:/td|tr|tbody/i,useDom:false,createDom:function(q,w){var r,z=document,u,x,s,y,v,t;if(Ext.isArray(q)){r=z.createDocumentFragment();for(v=0,t=q.length;v<t;v++){this.createDom(q[v],r)}}else{if(typeof q=="string"){r=z.createTextNode(q)}else{r=z.createElement(q.tag||"div");u=!!r.setAttribute;for(x in q){if(!this.confRe.test(x)){s=q[x];if(x=="cls"){r.className=s}else{if(u){r.setAttribute(x,s)}else{r[x]=s}}}}Ext.DomHelper.applyStyles(r,q.style);if((y=q.children||q.cn)){this.createDom(y,r)}else{if(q.html){r.innerHTML=q.html}}}}if(w){w.appendChild(r)}return r},ieTable:function(v,q,w,u){p.innerHTML=[q,w,u].join("");var r=-1,t=p,s;while(++r<v){t=t.firstChild}s=t.nextSibling;if(s){t=document.createDocumentFragment();while(s){t.appendChild(s);s=s.nextSibling}}return t},insertIntoTable:function(z,s,r,t){var q,w,v=s==a,y=s==b,u=s==o,x=s==i;if(z=="td"&&(y||u)||!this.tableElRe.test(z)&&(v||x)){return null}w=v?r:x?r.nextSibling:y?r.firstChild:null;if(v||x){r=r.parentNode}if(z=="td"||(z=="tr"&&(u||y))){q=this.ieTable(4,k,t,e)}else{if((z=="tbody"&&(u||y))||(z=="tr"&&(v||x))){q=this.ieTable(3,c,t,n)}else{q=this.ieTable(2,l,t,h)}}r.insertBefore(q,w);return q},createContextualFragment:function(r){var q=document.createDocumentFragment(),s,t;p.innerHTML=r;t=p.childNodes;s=t.length;while(s--){q.appendChild(t[0])}return q},applyStyles:function(q,r){if(r){q=Ext.fly(q);if(typeof r=="function"){r=r.call()}if(typeof r=="string"){r=Ext.dom.Element.parseStyles(r)}if(typeof r=="object"){q.setStyle(r)}}},createHtml:function(q){return this.markup(q)},doInsert:function(t,v,u,w,s,q){t=t.dom||Ext.getDom(t);var r;if(this.useDom){r=this.createDom(v,null);if(q){t.appendChild(r)}else{(s=="firstChild"?t:t.parentNode).insertBefore(r,t[s]||t)}}else{r=this.insertHtml(w,t,this.markup(v))}return u?Ext.get(r,true):r},overwrite:function(s,r,t){var q;s=Ext.getDom(s);r=this.markup(r);if(Ext.isIE&&this.tableRe.test(s.tagName)){while(s.firstChild){s.removeChild(s.firstChild)}if(r){q=this.insertHtml("afterbegin",s,r);return t?Ext.get(q):q}return null}s.innerHTML=r;return t?Ext.get(s.firstChild):s.firstChild},insertHtml:function(s,v,t){var x,r,u,q,w;s=s.toLowerCase();if(v.insertAdjacentHTML){if(Ext.isIE&&this.tableRe.test(v.tagName)&&(w=this.insertIntoTable(v.tagName.toLowerCase(),s,v,t))){return w}if((x=g[s])){v.insertAdjacentHTML(x[0],t);return v[x[1]]}}else{if(v.nodeType===3){s=s==="afterbegin"?"beforebegin":s;s=s==="beforeend"?"afterend":s}r=Ext.supports.CreateContextualFragment?v.ownerDocument.createRange():undefined;q="setStart"+(this.endRe.test(s)?"After":"Before");if(d[s]){if(r){r[q](v);w=r.createContextualFragment(t)}else{w=this.createContextualFragment(t)}v.parentNode.insertBefore(w,s==a?v:v.nextSibling);return v[(s==a?"previous":"next")+"Sibling"]}else{u=(s==b?"first":"last")+"Child";if(v.firstChild){if(r){r[q](v[u]);w=r.createContextualFragment(t)}else{w=this.createContextualFragment(t)}if(s==b){v.insertBefore(w,v.firstChild)}else{v.appendChild(w)}}else{v.innerHTML=t}return v[u]}}},createTemplate:function(r){var q=this.markup(r);return new Ext.Template(q)}},function(){Ext.ns("Ext.core");Ext.DomHelper=Ext.core.DomHelper=new this})}());Ext.ns("Ext.core");Ext.dom.Query=Ext.core.DomQuery=Ext.DomQuery=(function(){var cache={},simpleCache={},valueCache={},nonSpace=/\S/,trimRe=/^\s+|\s+$/g,tplRe=/\{(\d+)\}/g,modeRe=/^(\s?[\/>+~]\s?|\s|$)/,tagTokenRe=/^(#)?([\w\-\*\\]+)/,nthRe=/(\d*)n\+?(\d*)/,nthRe2=/\D/,startIdRe=/^\s*\#/,isIE=window.ActiveXObject?true:false,key=30803,longHex=/\\([0-9a-fA-F]{6})/g,shortHex=/\\([0-9a-fA-F]{1,6})\s{0,1}/g,nonHex=/\\([^0-9a-fA-F]{1})/g,escapes=/\\/g,num,hasEscapes,longHexToChar=function($0,$1){return String.fromCharCode(parseInt($1,16))},shortToLongHex=function($0,$1){while($1.length<6){$1="0"+$1}return"\\"+$1},charToLongHex=function($0,$1){num=$1.charCodeAt(0).toString(16);if(num.length===1){num="0"+num}return"\\0000"+num},unescapeCssSelector=function(selector){return(hasEscapes)?selector.replace(longHex,longHexToChar):selector},setupEscapes=function(path){hasEscapes=(path.indexOf("\\")>-1);if(hasEscapes){path=path.replace(shortHex,shortToLongHex).replace(nonHex,charToLongHex).replace(escapes,"\\\\")}return path};eval("var batch = 30803;");function child(parent,index){var i=0,n=parent.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(parent){var n=parent.firstChild,nodeIndex=-1,nextNode;while(n){nextNode=n.nextSibling;if(n.nodeType==3&&!nonSpace.test(n.nodeValue)){parent.removeChild(n)}else{n.nodeIndex=++nodeIndex}n=nextNode}return this}function byClassName(nodeSet,cls){cls=unescapeCssSelector(cls);if(!cls){return nodeSet}var result=[],ri=-1,i,ci;for(i=0,ci;ci=nodeSet[i];i++){if((" "+ci.className+" ").indexOf(cls)!=-1){result[++ri]=ci}}return result}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,i,ni,j,ci,cn,utag,n,cj;if(!ns){return result}tagName=tagName||"*";if(typeof ns.getElementsByTagName!="undefined"){ns=[ns]}if(!mode){for(i=0,ni;ni=ns[i];i++){cs=ni.getElementsByTagName(tagName);for(j=0,ci;ci=cs[j];j++){result[++ri]=ci}}}else{if(mode=="/"||mode==">"){utag=tagName.toUpperCase();for(i=0,ni,cn;ni=ns[i];i++){cn=ni.childNodes;for(j=0,cj;cj=cn[j];j++){if(cj.nodeName==utag||cj.nodeName==tagName||tagName=="*"){result[++ri]=cj}}}}else{if(mode=="+"){utag=tagName.toUpperCase();for(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=="~"){utag=tagName.toUpperCase();for(i=0,n;n=ns[i];i++){while((n=n.nextSibling)){if(n.nodeName==utag||n.nodeName==tagName||tagName=="*"){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 result=[],ri=-1,i,ci;tagName=tagName.toLowerCase();for(i=0,ci;ci=cs[i];i++){if(ci.nodeType==1&&ci.tagName.toLowerCase()==tagName){result[++ri]=ci}}return result}function byId(cs,id){id=unescapeCssSelector(id);if(cs.tagName||cs==document){cs=[cs]}if(!id){return cs}var result=[],ri=-1,i,ci;for(i=0,ci;ci=cs[i];i++){if(ci&&ci.id==id){result[++ri]=ci;return result}}return result}function byAttribute(cs,attr,value,op,custom){var result=[],ri=-1,useGetStyle=custom=="{",fn=Ext.DomQuery.operators[op],a,xml,hasXml,i,ci;value=unescapeCssSelector(value);for(i=0,ci;ci=cs[i];i++){if(ci.nodeType!=1){continue}if(!hasXml){xml=Ext.DomQuery.isXml(ci);hasXml=true}if(!xml){if(useGetStyle){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)}}}}}else{a=ci.getAttribute(attr)}if((fn&&fn(a,value))||(!fn&&a)){result[++ri]=ci}}return result}function byPseudo(cs,name,value){value=unescapeCssSelector(value);return Ext.DomQuery.pseudos[name](cs,value)}function nodupIEXml(cs){var d=++key,r,i,len,c;cs[0].setAttribute("_nodup",d);r=[cs[0]];for(i=1,len=cs.length;i<len;i++){c=cs[i];if(!c.getAttribute("_nodup")!=d){c.setAttribute("_nodup",d);r[r.length]=c}}for(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,d,j;if(!len||typeof cs.nodeType!="undefined"||len==1){return cs}if(isIE&&typeof cs[0].selectSingleNode!="undefined"){return nodupIEXml(cs)}d=++key;cs[0]._nodup=d;for(i=1;c=cs[i];i++){if(c._nodup!=d){c._nodup=d}else{r=[];for(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,r=[],i,len;for(i=0,len=c1.length;i<len;i++){c1[i].setAttribute("_qdiff",d)}for(i=0,len=c2.length;i<len;i++){if(c2[i].getAttribute("_qdiff")!=d){r[r.length]=c2[i]}}for(i=0,len=c1.length;i<len;i++){c1[i].removeAttribute("_qdiff")}return r}function quickDiff(c1,c2){var len1=c1.length,d=++key,r=[],i,len;if(!len1){return c2}if(isIE&&typeof c1[0].selectSingleNode!="undefined"){return quickDiffIEXml(c1,c2)}for(i=0;i<len1;i++){c1[i]._qdiff=d}for(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){id=unescapeCssSelector(id);var d=root.ownerDocument||root;return d.getElementById(id)}ns=getNodes(ns,mode,"*");return byId(ns,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"],mode,lastPath,matchers=Ext.DomQuery.matchers,matchersLn=matchers.length,modeMatch,lmode=path.match(modeRe),tokenMatch,matched,j,t,m;path=setupEscapes(path);if(lmode&&lmode[1]){fn[fn.length]='mode="'+lmode[1].replace(trimRe,"")+'";';path=path.replace(lmode[1],"")}while(path.substr(0,1)=="/"){path=path.substr(1)}while(path&&lastPath!=path){lastPath=path;tokenMatch=path.match(tagTokenRe);if(type=="select"){if(tokenMatch){if(tokenMatch[1]=="#"){fn[fn.length]='n = quickId(n, mode, root, "'+tokenMatch[2]+'");'}else{fn[fn.length]='n = getNodes(n, mode, "'+tokenMatch[2]+'");'}path=path.replace(tokenMatch[0],"")}else{if(path.substr(0,1)!="@"){fn[fn.length]='n = getNodes(n, mode, "*");'}}}else{if(tokenMatch){if(tokenMatch[1]=="#"){fn[fn.length]='n = byId(n, "'+tokenMatch[2]+'");'}else{fn[fn.length]='n = byTag(n, "'+tokenMatch[2]+'");'}path=path.replace(tokenMatch[0],"")}}while(!(modeMatch=path.match(modeRe))){matched=false;for(j=0;j<matchersLn;j++){t=matchers[j];m=path.match(t.re);if(m){fn[fn.length]=t.select.replace(tplRe,function(x,i){return m[i]});path=path.replace(m[0],"");matched=true;break}}if(!matched){Ext.Error.raise({sourceClass:"Ext.DomQuery",sourceMethod:"compile",msg:'Error parsing selector. Parsing failed at "'+path+'"'})}}if(modeMatch[1]){fn[fn.length]='mode="'+modeMatch[1].replace(trimRe,"")+'";';path=path.replace(modeMatch[1],"")}}fn[fn.length]="return nodup(n);\n}";eval(fn.join(""));return f},jsSelect:function(path,root,type){root=root||document;if(typeof root=="string"){root=document.getElementById(root)}var paths=path.split(","),results=[],i,len,subPath,result;for(i=0,len=paths.length;i<len;i++){subPath=paths[i].replace(trimRe,"");if(!cache[subPath]){cache[subPath]=Ext.DomQuery.compile(subPath,type);if(!cache[subPath]){Ext.Error.raise({sourceClass:"Ext.DomQuery",sourceMethod:"jsSelect",msg:subPath+" is not a valid selector"})}}else{setupEscapes(subPath)}result=cache[subPath](root);if(result&&result!=document){results=results.concat(result)}}if(paths.length>1){return nodup(results)}return results},isXml:function(el){var docEl=(el?el.ownerDocument||el:0).documentElement;return docEl?docEl.nodeName!=="HTML":false},select:document.querySelectorAll?function(path,root,type){root=root||document;if(!Ext.DomQuery.isXml(root)){try{if(root.parentNode&&(root.nodeType!==9)&&path.indexOf(",")===-1&&!startIdRe.test(path)){path="#"+Ext.escapeId(Ext.id(root))+" "+path;root=root.parentNode}return Ext.Array.toArray(root.querySelectorAll(path))}catch(e){}}return Ext.DomQuery.jsSelect.call(this,path,root,type)}:function(path,root,type){return Ext.DomQuery.jsSelect.call(this,path,root,type)},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")}else{setupEscapes(path)}var n=valueCache[path](root),v;n=n[0]?n[0]:n;if(typeof n.normalize=="function"){n.normalize()}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),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")}else{setupEscapes(ss)}var result=simpleCache[ss](els);return nonMatches?quickDiff(result,els):result},matchers:[{re:/^\.([\w\-\\]+)/,select:'n = byClassName(n, " {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, "{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,i,ci;for(i=0;(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,i,ci;for(i=0;(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,m=nthRe.exec(a=="even"&&"2n"||a=="odd"&&"2n+1"||!nthRe2.test(a)&&"n+"+a||a),f=(m[1]||1)-0,l=m[2]-0,i,n,j,cn,pn;for(i=0;n=c[i];i++){pn=n.parentNode;if(batch!=pn._batch){j=0;for(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,i,ci;for(i=0;ci=c[i];i++){if(!prev(ci)&&!next(ci)){r[++ri]=ci}}return r},empty:function(c){var r=[],ri=-1,i,ci,cns,j,cn,empty;for(i=0,ci;ci=c[i];i++){cns=ci.childNodes;j=0;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,i,ci;for(i=0;ci=c[i];i++){if((ci.textContent||ci.innerText||ci.text||"").indexOf(v)!=-1){r[++ri]=ci}}return r},nodeValue:function(c,v){var r=[],ri=-1,i,ci;for(i=0;ci=c[i];i++){if(ci.firstChild&&ci.firstChild.nodeValue==v){r[++ri]=ci}}return r},checked:function(c){var r=[],ri=-1,i,ci;for(i=0;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("|"),r=[],ri=-1,s,i,ci,j;for(i=0;ci=c[i];i++){for(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,r=[],ri=-1,i,ci;for(i=0;ci=c[i];i++){if(s(ss,ci).length>0){r[++ri]=ci}}return r},next:function(c,ss){var is=Ext.DomQuery.is,r=[],ri=-1,i,ci,n;for(i=0;ci=c[i];i++){n=next(ci);if(n&&is(n,ss)){r[++ri]=ci}}return r},prev:function(c,ss){var is=Ext.DomQuery.is,r=[],ri=-1,i,ci,n;for(i=0;ci=c[i];i++){n=prev(ci);if(n&&is(n,ss)){r[++ri]=ci}}return r}}}}());Ext.query=Ext.DomQuery.select;(function(){var HIDDEN="hidden",DOC=document,VISIBILITY="visibility",DISPLAY="display",NONE="none",XMASKED=Ext.baseCSSPrefix+"masked",XMASKEDRELATIVE=Ext.baseCSSPrefix+"masked-relative",EXTELMASKMSG=Ext.baseCSSPrefix+"mask-msg",bodyRe=/^body/i,visFly,noBoxAdjust=Ext.isStrict?{select:1}:{input:1,select:1,textarea:1},isScrolled=function(c){var r=[],ri=-1,i,ci;for(i=0;ci=c[i];i++){if(ci.scrollTop>0||ci.scrollLeft>0){r[++ri]=ci}}return r},Element=Ext.define("Ext.dom.Element",{extend:"Ext.dom.AbstractElement",alternateClassName:["Ext.Element","Ext.core.Element"],addUnits:function(){return this.self.addUnits.apply(this.self,arguments)},focus:function(defer,dom){var me=this,scrollTop,body;dom=dom||me.dom;body=(dom.ownerDocument||DOC).body||DOC.body;try{if(Number(defer)){Ext.defer(me.focus,defer,me,[null,dom])}else{if(dom.offsetHeight>Element.getViewHeight()){scrollTop=body.scrollTop}dom.focus();if(scrollTop!==undefined){body.scrollTop=scrollTop}}}catch(e){}return me},blur:function(){try{this.dom.blur()}catch(e){}return this},isBorderBox:function(){var box=Ext.isBorderBox;if(box){box=!((this.dom.tagName||"").toLowerCase() in noBoxAdjust)}return box},hover:function(overFn,outFn,scope,options){var me=this;me.on("mouseenter",overFn,scope||me.dom,options);me.on("mouseleave",outFn,scope||me.dom,options);return me},getAttributeNS:function(ns,name){return this.getAttribute(name,ns)},getAttribute:(Ext.isIE&&!(Ext.isIE9&&DOC.documentMode===9))?function(name,ns){var d=this.dom,type;if(ns){type=typeof d[ns+":"+name];if(type!="undefined"&&type!="unknown"){return d[ns+":"+name]||null}return null}if(name==="for"){name="htmlFor"}return d[name]||null}:function(name,ns){var d=this.dom;if(ns){return d.getAttributeNS(ns,name)||d.getAttribute(ns+":"+name)}return d.getAttribute(name)||d[name]||null},cacheScrollValues:function(){var me=this,scrolledDescendants,el,i,scrollValues=[],result=function(){for(i=0;i<scrolledDescendants.length;i++){el=scrolledDescendants[i];el.scrollLeft=scrollValues[i][0];el.scrollTop=scrollValues[i][1]}};if(!Ext.DomQuery.pseudos.isScrolled){Ext.DomQuery.pseudos.isScrolled=isScrolled}scrolledDescendants=me.query(":isScrolled");for(i=0;i<scrolledDescendants.length;i++){el=scrolledDescendants[i];scrollValues[i]=[el.scrollLeft,el.scrollTop]}return result},autoBoxAdjust:true,isVisible:function(deep){var me=this,dom=me.dom,stopNode=dom.ownerDocument.documentElement;if(!visFly){visFly=new Element.Fly()}while(dom!==stopNode){if(!dom||dom.nodeType===11||(visFly.attach(dom)).isStyle(VISIBILITY,HIDDEN)||visFly.isStyle(DISPLAY,NONE)){return false}if(!deep){break}dom=dom.parentNode}return true},isDisplayed:function(){return !this.isStyle(DISPLAY,NONE)},enableDisplayMode:function(display){var me=this;me.setVisibilityMode(Element.DISPLAY);if(!Ext.isEmpty(display)){(me.$cache||me.getCache()).data.originalDisplay=display}return me},mask:function(msg,msgCls,elHeight){var me=this,dom=me.dom,setExpression=dom.style.setExpression,data=(me.$cache||me.getCache()).data,maskEl=data.maskEl,maskMsg=data.maskMsg;if(!(bodyRe.test(dom.tagName)&&me.getStyle("position")=="static")){me.addCls(XMASKEDRELATIVE)}if(maskEl){maskEl.remove()}if(maskMsg){maskMsg.remove()}Ext.DomHelper.append(dom,[{cls:Ext.baseCSSPrefix+"mask"},{cls:msgCls?EXTELMASKMSG+" "+msgCls:EXTELMASKMSG,cn:{tag:"div",html:msg||""}}]);maskMsg=Ext.get(dom.lastChild);maskEl=Ext.get(maskMsg.dom.previousSibling);data.maskMsg=maskMsg;data.maskEl=maskEl;me.addCls(XMASKED);maskEl.setDisplayed(true);if(typeof msg=="string"){maskMsg.setDisplayed(true);maskMsg.center(me)}else{maskMsg.setDisplayed(false)}if(!Ext.supports.IncludePaddingInWidthCalculation&&setExpression){try{maskEl.dom.style.setExpression("width",'this.parentNode.clientWidth + "px"')}catch(e){}}if(!Ext.supports.IncludePaddingInHeightCalculation&&setExpression){try{maskEl.dom.style.setExpression("height","this.parentNode."+(dom==DOC.body?"scrollHeight":"offsetHeight")+' + "px"')}catch(e){}}else{if(Ext.isIE&&!(Ext.isIE7&&Ext.isStrict)&&me.getStyle("height")=="auto"){maskEl.setSize(undefined,elHeight||me.getHeight())}}return maskEl},unmask:function(){var me=this,data=(me.$cache||me.getCache()).data,maskEl=data.maskEl,maskMsg=data.maskMsg,style;if(maskEl){style=maskEl.dom.style;if(style.clearExpression){style.clearExpression("width");style.clearExpression("height")}if(maskEl){maskEl.remove();delete data.maskEl}if(maskMsg){maskMsg.remove();delete data.maskMsg}me.removeCls([XMASKED,XMASKEDRELATIVE])}},isMasked:function(){var me=this,data=(me.$cache||me.getCache()).data,maskEl=data.maskEl,maskMsg=data.maskMsg,hasMask=false;if(maskEl&&maskEl.isVisible()){if(maskMsg){maskMsg.center(me)}hasMask=true}return hasMask},createShim:function(){var el=DOC.createElement("iframe"),shim;el.frameBorder="0";el.className=Ext.baseCSSPrefix+"shim";el.src=Ext.SSL_SECURE_URL;shim=Ext.get(this.dom.parentNode.insertBefore(el,this.dom));shim.autoBoxAdjust=false;return shim},addKeyListener:function(key,fn,scope){var config;if(typeof key!="object"||Ext.isArray(key)){config={target:this,key:key,fn:fn,scope:scope}}else{config={target:this,key:key.key,shift:key.shift,ctrl:key.ctrl,alt:key.alt,fn:fn,scope:scope}}return new Ext.util.KeyMap(config)},addKeyMap:function(config){return new Ext.util.KeyMap(Ext.apply({target:this},config))},on:function(eventName,fn,scope,options){Ext.EventManager.on(this,eventName,fn,scope||this,options);return this},un:function(eventName,fn,scope){Ext.EventManager.un(this,eventName,fn,scope||this);return this},removeAllListeners:function(){Ext.EventManager.removeAll(this);return this},purgeAllListeners:function(){Ext.EventManager.purgeElement(this);return this}},function(){var EC=Ext.cache,El=this,AbstractElement=Ext.dom.AbstractElement,focusRe=/a|button|embed|iframe|img|input|object|select|textarea/i,nonSpaceRe=/\S/,scriptTagRe=/(?:<script([^>]*)?>)((\n|\r|.)*?)(?:<\/script>)/ig,replaceScriptTagRe=/(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)/ig,srcRe=/\ssrc=([\'\"])(.*?)\1/i,typeRe=/\stype=([\'\"])(.*?)\1/i,useDocForId=!(Ext.isIE6||Ext.isIE7||Ext.isIE8);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>';function garbageCollect(){if(!Ext.enableGarbageCollector){clearInterval(El.collectorThreadId)}else{var eid,d,o,t;for(eid in EC){if(!EC.hasOwnProperty(eid)){continue}o=EC[eid];if(o.skipGarbageCollection){continue}d=o.dom;if(!d.parentNode||(!d.offsetParent&&!Ext.getElementById(eid))){if(d&&Ext.enableListenerCollection){Ext.EventManager.removeAll(d)}delete EC[eid]}}if(Ext.isIE){t={};for(eid in EC){if(!EC.hasOwnProperty(eid)){continue}t[eid]=EC[eid]}EC=Ext.cache=t}}}El.collectorThreadId=setInterval(garbageCollect,30000);El.addMethods({monitorMouseLeave:function(delay,handler,scope){var me=this,timer,listeners={mouseleave:function(e){timer=setTimeout(Ext.Function.bind(handler,scope||me,[e]),delay)},mouseenter:function(){clearTimeout(timer)},freezeEvent:true};me.on(listeners);return listeners},swallowEvent:function(eventName,preventDefault){var me=this,e,eLen;function fn(e){e.stopPropagation();if(preventDefault){e.preventDefault()}}if(Ext.isArray(eventName)){eLen=eventName.length;for(e=0;e<eLen;e++){me.on(eventName[e],fn)}return me}me.on(eventName,fn);return me},relayEvent:function(eventName,observable){this.on(eventName,function(e){observable.fireEvent(eventName,e)})},clean:function(forceReclean){var me=this,dom=me.dom,data=(me.$cache||me.getCache()).data,n=dom.firstChild,ni=-1,nx;if(data.isCleaned&&forceReclean!==true){return me}while(n){nx=n.nextSibling;if(n.nodeType==3){if(!(nonSpaceRe.test(n.nodeValue))){dom.removeChild(n)}else{if(nx&&nx.nodeType==3){n.appendData(Ext.String.trim(nx.data));dom.removeChild(nx);nx=n.nextSibling;n.nodeIndex=++ni}}}else{Ext.fly(n).clean();n.nodeIndex=++ni}n=nx}data.isCleaned=true;return me},load:function(options){this.getLoader().load(options);return this},getLoader:function(){var me=this,data=(me.$cache||me.getCache()).data,loader=data.loader;if(!loader){data.loader=loader=new Ext.ElementLoader({target:me})}return loader},syncContent:function(source){source=Ext.getDom(source);var me=this,sourceNodes=source.childNodes,sourceLen=sourceNodes.length,dest=me.dom,destNodes=dest.childNodes,destLen=destNodes.length,i,destNode,sourceNode,nodeType;dest.style.cssText=source.style.cssText;dest.className=source.className;if(sourceLen!==destLen){source.innerHTML=dest.innerHTML;return}for(i=0;i<sourceLen;i++){sourceNode=sourceNodes[i];destNode=destNodes[i];nodeType=sourceNode.nodeType;if(nodeType!==destNode.nodeType||(nodeType===1&&sourceNode.tagName!==destNode.tagName)){dest.innerHTML=source.innerHTML;return}if(nodeType===3){destNode.data=sourceNode.data}else{if(sourceNode.id&&destNode.id!==sourceNode.id){destNode.id=sourceNode.id}destNode.style.cssText=sourceNode.style.cssText;destNode.className=sourceNode.className;Ext.fly(destNode).syncContent(sourceNode)}}},update:function(html,loadScripts,callback){var me=this,id,dom,interval;if(!me.dom){return me}html=html||"";dom=me.dom;if(loadScripts!==true){dom.innerHTML=html;Ext.callback(callback,me);return me}id=Ext.id();html+='<span id="'+id+'"></span>';interval=setInterval(function(){var hd,match,attrs,srcMatch,typeMatch,el,s;if(!(el=DOC.getElementById(id))){return false}clearInterval(interval);Ext.removeNode(el);hd=Ext.getHead().dom;while((match=scriptTagRe.exec(html))){attrs=match[1];srcMatch=attrs?attrs.match(srcRe):false;if(srcMatch&&srcMatch[2]){s=DOC.createElement("script");s.src=srcMatch[2];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])}}}}Ext.callback(callback,me)},20);dom.innerHTML=html.replace(replaceScriptTagRe,"");return me},removeAllListeners:function(){this.removeAnchor();Ext.EventManager.removeAll(this.dom);return this},createProxy:function(config,renderTo,matchBox){config=(typeof config=="object")?config:{tag:"div",cls:config};var me=this,proxy=renderTo?Ext.DomHelper.append(renderTo,config,true):Ext.DomHelper.insertBefore(me.dom,config,true);proxy.setVisibilityMode(Element.DISPLAY);proxy.hide();if(matchBox&&me.setBox&&me.getBox){proxy.setBox(me.getBox())}return proxy},getScopeParent:function(){var parent=this.dom.parentNode;if(Ext.scopeResetCSS){parent=parent.parentNode;if(!Ext.supports.CSS3LinearGradient||!Ext.supports.CSS3BorderRadius){parent=parent.parentNode}}return parent},needsTabIndex:function(){if(this.dom){if((this.dom.nodeName==="a")&&(!this.dom.href)){return true}return !focusRe.test(this.dom.nodeName)}},focusable:function(){var dom=this.dom,nodeName=dom.nodeName,canFocus=false;if(!dom.disabled){if(focusRe.test(nodeName)){if((nodeName!=="a")||dom.href){canFocus=true}}else{canFocus=!isNaN(dom.tabIndex)}}return canFocus&&this.isVisible(true)}});if(Ext.isIE){El.prototype.getById=function(id,asDom){var dom=this.dom,cacheItem,el,ret;if(dom){el=(useDocForId&&DOC.getElementById(id))||dom.all[id];if(el){if(asDom){ret=el}else{cacheItem=EC[id];if(cacheItem&&cacheItem.el){ret=Ext.updateCacheEntry(cacheItem,el).el}else{ret=new Element(el)}}return ret}}return asDom?Ext.getDom(id):El.get(id)}}El.createAlias({addListener:"on",removeListener:"un",clearListeners:"removeAllListeners"});El.Fly=AbstractElement.Fly=new Ext.Class({extend:El,constructor:function(dom){this.dom=dom},attach:AbstractElement.Fly.prototype.attach});if(Ext.isIE){Ext.getElementById=function(id){var el=DOC.getElementById(id),detachedBodyEl;if(!el&&(detachedBodyEl=AbstractElement.detachedBodyEl)){el=detachedBodyEl.dom.all[id]}return el}}else{if(!DOC.querySelector){Ext.getDetachedBody=Ext.getBody;Ext.getElementById=function(id){return DOC.getElementById(id)}}}})}());Ext.dom.Element.override((function(){var d=document,c=window,a=/^([a-z]+)-([a-z]+)(\?)?$/,b=Math.round;return{getAnchorXY:function(j,o,h){j=(j||"tl").toLowerCase();h=h||{};var m=this,i=m.dom==d.body||m.dom==d,e=h.width||i?Ext.dom.Element.getViewWidth():m.getWidth(),g=h.height||i?Ext.dom.Element.getViewHeight():m.getHeight(),q,n=m.getXY(),p=m.getScroll(),l=i?p.left:!o?n[0]:0,k=i?p.top:!o?n[1]:0;switch(j){case"tl":q=[0,0];break;case"bl":q=[0,g];break;case"tr":q=[e,0];break;case"c":q=[b(e*0.5),b(g*0.5)];break;case"t":q=[b(e*0.5),0];break;case"l":q=[0,b(g*0.5)];break;case"r":q=[e,b(g*0.5)];break;case"b":q=[b(e*0.5),g];break;case"br":q=[e,g]}return[q[0]+l,q[1]+k]},getAlignToXY:function(m,G,j){m=Ext.get(m);if(!m||!m.dom){}j=j||[0,0];G=(!G||G=="?"?"tl-bl?":(!(/-/).test(G)&&G!==""?"tl-"+G:G||"tl-bl")).toLowerCase();var H=this,l,w,q,o,k,z,A,E=Ext.dom.Element.getViewWidth()-10,i=Ext.dom.Element.getViewHeight()-10,g,h,n,p,u,v,F=d.documentElement,s=d.body,D=(F.scrollLeft||s.scrollLeft||0),B=(F.scrollTop||s.scrollTop||0),C,t,r,e=G.match(a);t=e[1];r=e[2];C=!!e[3];l=H.getAnchorXY(t,true);w=m.getAnchorXY(r,false);q=w[0]-l[0]+j[0];o=w[1]-l[1]+j[1];if(C){k=H.getWidth();z=H.getHeight();A=m.getRegion();g=t.charAt(0);h=t.charAt(t.length-1);n=r.charAt(0);p=r.charAt(r.length-1);u=((g=="t"&&n=="b")||(g=="b"&&n=="t"));v=((h=="r"&&p=="l")||(h=="l"&&p=="r"));if(q+k>E+D){q=v?A.left-k:E+D-k}if(q<D){q=v?A.right:D}if(o+z>i+B){o=u?A.top-z:i+B-z}if(o<B){o=u?A.bottom:B}}return[q,o]},anchorTo:function(g,l,h,e,o,p){var m=this,j=m.dom,n=!Ext.isEmpty(o),i=function(){Ext.fly(j).alignTo(g,l,h,e);Ext.callback(p,Ext.fly(j))},k=this.getAnchor();this.removeAnchor();Ext.apply(k,{fn:i,scroll:n});Ext.EventManager.onWindowResize(i,null);if(n){Ext.EventManager.on(c,"scroll",i,null,{buffer:!isNaN(o)?o:50})}i.call(m);return m},removeAnchor:function(){var g=this,e=this.getAnchor();if(e&&e.fn){Ext.EventManager.removeResizeListener(e.fn);if(e.scroll){Ext.EventManager.un(c,"scroll",e.fn)}delete e.fn}return g},getAlignVector:function(h,g,j){var i=this,e=i.getXY(),k=i.getAlignToXY(h,g,j);h=Ext.get(h);k[0]-=e[0];k[1]-=e[1];return k},alignTo:function(h,e,j,g){var i=this;return i.setXY(i.getAlignToXY(h,e,j),i.anim&&!!g?i.anim(g):false)},getConstrainVector:function(i,g){if(!(i instanceof Ext.util.Region)){i=Ext.get(i).getViewRegion()}var k=this.getRegion(),e=[0,0],j=(this.shadow&&!this.shadowDisabled)?this.shadow.getShadowSize():undefined,h=false;if(g){k.translateBy(g[0]-k.x,g[1]-k.y)}if(j){i.adjust(j[0],-j[1],-j[2],j[3])}if(k.right>i.right){h=true;e[0]=(i.right-k.right)}if(k.left+e[0]<i.left){h=true;e[0]=(i.left-k.left)}if(k.bottom>i.bottom){h=true;e[1]=(i.bottom-k.bottom)}if(k.top+e[1]<i.top){h=true;e[1]=(i.top-k.top)}return h?e:false},getCenterXY:function(){return this.getAlignToXY(d,"c-c")},center:function(e){return this.alignTo(e||d,"c-c")}}}()));Ext.dom.Element.override({animate:function(b){var d=this,c,e,a=d.dom.id||Ext.id(d.dom);if(!Ext.fx.Manager.hasFxBlock(a)){if(b.listeners){c=b.listeners;delete b.listeners}if(b.internalListeners){b.listeners=b.internalListeners;delete b.internalListeners}e=new Ext.fx.Anim(d.anim(b));if(c){e.on(c)}Ext.fx.Manager.queueFx(e)}return d},anim:function(a){if(!Ext.isObject(a)){return(a)?{}:false}var b=this,c=a.duration||Ext.fx.Anim.prototype.duration,e=a.easing||"ease",d;if(a.stopAnimation){b.stopAnimation()}Ext.applyIf(a,Ext.fx.Manager.getFxDefaults(b.id));Ext.fx.Manager.setFxDefaults(b.id,{delay:0});d={target:b.dom,remove:a.remove,alternate:a.alternate||false,duration:c,easing:e,callback:a.callback,listeners:a.listeners,iterations:a.iterations||1,scope:a.scope,block:a.block,concurrent:a.concurrent,delay:a.delay||0,paused:true,keyframes:a.keyframes,from:a.from||{},to:Ext.apply({},a)};Ext.apply(d.to,a.to);delete d.to.to;delete d.to.from;delete d.to.remove;delete d.to.alternate;delete d.to.keyframes;delete d.to.iterations;delete d.to.listeners;delete d.to.target;delete d.to.paused;delete d.to.callback;delete d.to.scope;delete d.to.duration;delete d.to.easing;delete d.to.concurrent;delete d.to.block;delete d.to.stopAnimation;delete d.to.delay;return d},slideIn:function(c,b,d){var g=this,j=g.dom.style,i,a,e,h;c=c||"t";b=b||{};i=function(){var n=this,m=b.listeners,o,k,p,l;if(!d){g.fixDisplay()}o=g.getBox();if((c=="t"||c=="b")&&o.height===0){o.height=g.dom.scrollHeight}else{if((c=="l"||c=="r")&&o.width===0){o.width=g.dom.scrollWidth}}k=g.getStyles("width","height","left","right","top","bottom","position","z-index",true);g.setSize(o.width,o.height);if(b.preserveScroll){e=g.cacheScrollValues()}l=g.wrap({id:Ext.id()+"-anim-wrap-for-"+g.id,style:{visibility:d?"visible":"hidden"}});h=l.dom.parentNode;l.setPositioning(g.getPositioning());if(l.isStyle("position","static")){l.position("relative")}g.clearPositioning("auto");l.clip();if(e){e()}g.setStyle({visibility:"",position:"absolute"});if(d){l.setSize(o.width,o.height)}switch(c){case"t":p={from:{width:o.width+"px",height:"0px"},to:{width:o.width+"px",height:o.height+"px"}};j.bottom="0px";break;case"l":p={from:{width:"0px",height:o.height+"px"},to:{width:o.width+"px",height:o.height+"px"}};j.right="0px";break;case"r":p={from:{x:o.x+o.width,width:"0px",height:o.height+"px"},to:{x:o.x,width:o.width+"px",height:o.height+"px"}};break;case"b":p={from:{y:o.y+o.height,width:o.width+"px",height:"0px"},to:{y:o.y,width:o.width+"px",height:o.height+"px"}};break;case"tl":p={from:{x:o.x,y:o.y,width:"0px",height:"0px"},to:{width:o.width+"px",height:o.height+"px"}};j.bottom="0px";j.right="0px";break;case"bl":p={from:{y:o.y+o.height,width:"0px",height:"0px"},to:{y:o.y,width:o.width+"px",height:o.height+"px"}};j.bottom="0px";break;case"br":p={from:{x:o.x+o.width,y:o.y+o.height,width:"0px",height:"0px"},to:{x:o.x,y:o.y,width:o.width+"px",height:o.height+"px"}};break;case"tr":p={from:{x:o.x+o.width,width:"0px",height:"0px"},to:{x:o.x,width:o.width+"px",height:o.height+"px"}};j.right="0px";break}l.show();a=Ext.apply({},b);delete a.listeners;a=new Ext.fx.Anim(Ext.applyIf(a,{target:l,duration:500,easing:"ease-out",from:d?p.to:p.from,to:d?p.from:p.to}));a.on("afteranimate",function(){g.setStyle(k);if(d){if(b.useDisplay){g.setDisplayed(false)}else{g.hide()}}if(l.dom){if(l.dom.parentNode){l.dom.parentNode.insertBefore(g.dom,l.dom)}else{h.appendChild(g.dom)}l.remove()}if(e){e()}n.end()});if(m){a.on(m)}};g.animate({duration:b.duration?Math.max(b.duration,500)*2:1000,listeners:{beforeanimate:i}});return g},slideOut:function(a,b){return this.slideIn(a,b,true)},puff:function(e){var d=this,b,c=d.getBox(),a=d.getStyles("width","height","left","right","top","bottom","position","z-index","font-size","opacity",true);e=Ext.applyIf(e||{},{easing:"ease-out",duration:500,useDisplay:false});b=function(){d.clearOpacity();d.show();this.to={width:c.width*2,height:c.height*2,x:c.x-(c.width/2),y:c.y-(c.height/2),opacity:0,fontSize:"200%"};this.on("afteranimate",function(){if(d.dom){if(e.useDisplay){d.setDisplayed(false)}else{d.hide()}d.setStyle(a);e.callback.call(e.scope)}})};d.animate({duration:e.duration,easing:e.easing,listeners:{beforeanimate:{fn:b}}});return d},switchOff:function(c){var b=this,a;c=Ext.applyIf(c||{},{easing:"ease-in",duration:500,remove:false,useDisplay:false});a=function(){var h=this,g=b.getSize(),i=b.getXY(),e,d;b.clearOpacity();b.clip();d=b.getPositioning();e=new Ext.fx.Animator({target:b,duration:c.duration,easing:c.easing,keyframes:{33:{opacity:0.3},66:{height:1,y:i[1]+g.height/2},100:{width:1,x:i[0]+g.width/2}}});e.on("afteranimate",function(){if(c.useDisplay){b.setDisplayed(false)}else{b.hide()}b.clearOpacity();b.setPositioning(d);b.setSize(g);h.end()})};b.animate({duration:(Math.max(c.duration,500)*2),listeners:{beforeanimate:{fn:a}}});return b},frame:function(a,d,e){var c=this,b;a=a||"#C3DAF9";d=d||1;e=e||{};b=function(){c.show();var i=this,j=c.getBox(),h=Ext.getBody().createChild({id:c.id+"-anim-proxy",style:{position:"absolute","pointer-events":"none","z-index":35000,border:"0px solid "+a}}),g;g=new Ext.fx.Anim({target:h,duration:e.duration||1000,iterations:d,from:{top:j.y,left:j.x,borderWidth:0,opacity:1,height:j.height,width:j.width},to:{top:j.y-20,left:j.x-20,borderWidth:10,opacity:0,height:j.height+40,width:j.width+40}});g.on("afteranimate",function(){h.remove();i.end()})};c.animate({duration:(Math.max(e.duration,500)*2)||2000,listeners:{beforeanimate:{fn:b}}});return c},ghost:function(a,d){var c=this,b;a=a||"b";b=function(){var h=c.getWidth(),g=c.getHeight(),i=c.getXY(),e=c.getPositioning(),j={opacity:0};switch(a){case"t":j.y=i[1]-g;break;case"l":j.x=i[0]-h;break;case"r":j.x=i[0]+h;break;case"b":j.y=i[1]+g;break;case"tl":j.x=i[0]-h;j.y=i[1]-g;break;case"bl":j.x=i[0]-h;j.y=i[1]+g;break;case"br":j.x=i[0]+h;j.y=i[1]+g;break;case"tr":j.x=i[0]+h;j.y=i[1]-g;break}this.to=j;this.on("afteranimate",function(){if(c.dom){c.hide();c.clearOpacity();c.setPositioning(e)}})};c.animate(Ext.applyIf(d||{},{duration:500,easing:"ease-out",listeners:{beforeanimate:{fn:b}}}));return c},highlight:function(d,b){var i=this,e=i.dom,k={},h,l,g,c,a,j;b=b||{};c=b.listeners||{};g=b.attr||"backgroundColor";k[g]=d||"ffff9c";if(!b.to){l={};l[g]=b.endColor||i.getColor(g,"ffffff","")}else{l=b.to}b.listeners=Ext.apply(Ext.apply({},c),{beforeanimate:function(){h=e.style[g];i.clearOpacity();i.show();a=c.beforeanimate;if(a){j=a.fn||a;return j.apply(a.scope||c.scope||window,arguments)}},afteranimate:function(){if(e){e.style[g]=h}a=c.afteranimate;if(a){j=a.fn||a;j.apply(a.scope||c.scope||window,arguments)}}});i.animate(Ext.apply({},b,{duration:1000,easing:"ease-in",from:k,to:l}));return i},pause:function(a){var b=this;Ext.fx.Manager.setFxDefaults(b.id,{delay:a});return b},fadeIn:function(b){var a=this;a.animate(Ext.apply({},b,{opacity:1,internalListeners:{beforeanimate:function(c){if(a.isStyle("display","none")){a.setDisplayed("")}else{a.show()}}}}));return this},fadeOut:function(b){var a=this;b=Ext.apply({opacity:0,internalListeners:{afteranimate:function(c){var d=a.dom;if(d&&c.to.opacity===0){if(b.useDisplay){a.setDisplayed(false)}else{a.hide()}}}}},b);a.animate(b);return a},scale:function(a,b,c){this.animate(Ext.apply({},c,{width:a,height:b}));return this},shift:function(a){this.animate(a);return this}});Ext.dom.Element.override({initDD:function(c,b,d){var a=new Ext.dd.DD(Ext.id(this.dom),c,b);return Ext.apply(a,d)},initDDProxy:function(c,b,d){var a=new Ext.dd.DDProxy(Ext.id(this.dom),c,b);return Ext.apply(a,d)},initDDTarget:function(c,b,d){var a=new Ext.dd.DDTarget(Ext.id(this.dom),c,b);return Ext.apply(a,d)}});(function(){var b=Ext.dom.Element,i="visibility",g="display",n="none",e="hidden",m="visible",o="offsets",j="asclass",a="nosize",c="originalDisplay",d="visibilityMode",h="isVisible",l=Ext.baseCSSPrefix+"hide-offsets",k=function(q){var r=(q.$cache||q.getCache()).data,s=r[c];if(s===undefined){r[c]=s=""}return s},p=function(r){var s=(r.$cache||r.getCache()).data,q=s[d];if(q===undefined){s[d]=q=b.VISIBILITY}return q};b.override({originalDisplay:"",visibilityMode:1,setVisible:function(u,q){var s=this,t=s.dom,r=p(s);if(typeof q=="string"){switch(q){case g:r=b.DISPLAY;break;case i:r=b.VISIBILITY;break;case o:r=b.OFFSETS;break;case a:case j:r=b.ASCLASS;break}s.setVisibilityMode(r);q=false}if(!q||!s.anim){if(r==b.DISPLAY){return s.setDisplayed(u)}else{if(r==b.OFFSETS){s[u?"removeCls":"addCls"](l)}else{if(r==b.VISIBILITY){s.fixDisplay();t.style.visibility=u?"":e}else{if(r==b.ASCLASS){s[u?"removeCls":"addCls"](s.visibilityCls||b.visibilityCls)}}}}}else{if(u){s.setOpacity(0.01);s.setVisible(true)}if(!Ext.isObject(q)){q={duration:350,easing:"ease-in"}}s.animate(Ext.applyIf({callback:function(){if(!u){s.setVisible(false).setOpacity(1)}},to:{opacity:(u)?1:0}},q))}(s.$cache||s.getCache()).data[h]=u;return s},hasMetrics:function(){var q=p(this);return this.isVisible()||(q==b.OFFSETS)||(q==b.VISIBILITY)},toggle:function(q){var r=this;r.setVisible(!r.isVisible(),r.anim(q));return r},setDisplayed:function(q){if(typeof q=="boolean"){q=q?k(this):n}this.setStyle(g,q);return this},fixDisplay:function(){var q=this;if(q.isStyle(g,n)){q.setStyle(i,e);q.setStyle(g,k(q));if(q.isStyle(g,n)){q.setStyle(g,"block")}}},hide:function(q){if(typeof q=="string"){this.setVisible(false,q);return this}this.setVisible(false,this.anim(q));return this},show:function(q){if(typeof q=="string"){this.setVisible(true,q);return this}this.setVisible(true,this.anim(q));return this}})}());(function(){var r=Ext.dom.Element,n="left",k="right",q="top",h="bottom",o="position",j="static",x="relative",p="auto",v="z-index",u="BODY",c="padding",t="border",s="-left",m="-right",a="-top",l="-bottom",g="-width",e={l:t+s+g,r:t+m+g,t:t+a+g,b:t+l+g},d={l:c+s,r:c+m,t:c+a,b:c+l},w=[d.l,d.r,d.t,d.b],b=[e.l,e.r,e.t,e.b],i=["position","top","left"];r.override({getX:function(){return r.getX(this.dom)},getY:function(){return r.getY(this.dom)},getXY:function(){return r.getXY(this.dom)},getOffsetsTo:function(y){var A=this.getXY(),z=Ext.fly(y,"_internal").getXY();return[A[0]-z[0],A[1]-z[1]]},setX:function(y,z){return this.setXY([y,this.getY()],z)},setY:function(A,z){return this.setXY([this.getX(),A],z)},setLeft:function(y){this.setStyle(n,this.addUnits(y));return this},setTop:function(y){this.setStyle(q,this.addUnits(y));return this},setRight:function(y){this.setStyle(k,this.addUnits(y));return this},setBottom:function(y){this.setStyle(h,this.addUnits(y));return this},setXY:function(A,y){var z=this;if(!y||!z.anim){r.setXY(z.dom,A)}else{if(!Ext.isObject(y)){y={}}z.animate(Ext.applyIf({to:{x:A[0],y:A[1]}},y))}return z},pxRe:/^\d+(?:\.\d*)?px$/i,getLocalX:function(){var A=this,z,y=A.getStyle(n);if(!y||y===p){return 0}if(y&&A.pxRe.test(y)){return parseFloat(y)}y=A.getX();z=A.dom.offsetParent;if(z){y-=Ext.fly(z).getX()}return y},getLocalY:function(){var A=this,z,B=A.getStyle(q);if(!B||B===p){return 0}if(B&&A.pxRe.test(B)){return parseFloat(B)}B=A.getY();z=A.dom.offsetParent;if(z){B-=Ext.fly(z).getY()}return B},getLeft:function(y){return y?this.getLocalX():this.getX()},getRight:function(y){return(y?this.getLocalX():this.getX())+this.getWidth()},getTop:function(y){return y?this.getLocalY():this.getY()},getBottom:function(y){return(y?this.getLocalY():this.getY())+this.getHeight()},translatePoints:function(z,G){var B=this,A=B.getStyle(i),C=A.position=="relative",F=parseFloat(A.left),E=parseFloat(A.top),D=B.getXY();if(Ext.isArray(z)){G=z[1];z=z[0]}if(isNaN(F)){F=C?0:B.dom.offsetLeft}if(isNaN(E)){E=C?0:B.dom.offsetTop}F=(typeof z=="number")?z-D[0]+F:undefined;E=(typeof G=="number")?G-D[1]+E:undefined;return{left:F,top:E}},setBox:function(C,D,z){var B=this,y=C.width,A=C.height;if((D&&!B.autoBoxAdjust)&&!B.isBorderBox()){y-=(B.getBorderWidth("lr")+B.getPadding("lr"));A-=(B.getBorderWidth("tb")+B.getPadding("tb"))}B.setBounds(C.x,C.y,y,A,z);return B},getBox:function(D,I){var F=this,M,z,H,C,K,A,y,L,G,J,B,E;if(!I){M=F.getXY()}else{M=F.getStyle([n,q]);M=[parseFloat(M.left)||0,parseFloat(M.top)||0]}J=F.getWidth();B=F.getHeight();if(!D){E={x:M[0],y:M[1],0:M[0],1:M[1],width:J,height:B}}else{C=F.getStyle(w);K=F.getStyle(b);A=(parseFloat(K[e.l])||0)+(parseFloat(C[d.l])||0);y=(parseFloat(K[e.r])||0)+(parseFloat(C[d.r])||0);L=(parseFloat(K[e.t])||0)+(parseFloat(C[d.t])||0);G=(parseFloat(K[e.b])||0)+(parseFloat(C[d.b])||0);E={x:M[0]+A,y:M[1]+L,0:M[0]+A,1:M[1]+L,width:J-(A+y),height:B-(L+G)}}E.right=E.x+E.width;E.bottom=E.y+E.height;return E},getPageBox:function(B){var D=this,z=D.dom,F=z.nodeName==u,G=F?Ext.dom.AbstractElement.getViewWidth():z.offsetWidth,C=F?Ext.dom.AbstractElement.getViewHeight():z.offsetHeight,I=D.getXY(),H=I[1],y=I[0]+G,E=I[1]+C,A=I[0];if(B){return new Ext.util.Region(H,y,E,A)}else{return{left:A,top:H,width:G,height:C,right:y,bottom:E}}},setLocation:function(z,B,A){return this.setXY([z,B],A)},moveTo:function(z,B,A){return this.setXY([z,B],A)},position:function(D,C,z,B){var A=this;if(!D&&A.isStyle(o,j)){A.setStyle(o,x)}else{if(D){A.setStyle(o,D)}}if(C){A.setStyle(v,C)}if(z||B){A.setXY([z||false,B||false])}},clearPositioning:function(y){y=y||"";this.setStyle({left:y,right:y,top:y,bottom:y,"z-index":"",position:j});return this},getPositioning:function(){var y=this.getStyle([n,q,o,k,h,v]);y[k]=y[n]?"":y[k];y[h]=y[q]?"":y[h];return y},setPositioning:function(y){var A=this,z=A.dom.style;A.setStyle(y);if(y.right==p){z.right=""}if(y.bottom==p){z.bottom=""}return A},move:function(H,A,B){var E=this,K=E.getXY(),I=K[0],G=K[1],C=[I-A,G],J=[I+A,G],F=[I,G-A],z=[I,G+A],D={l:C,left:C,r:J,right:J,t:F,top:F,up:F,b:z,bottom:z,down:z};H=H.toLowerCase();E.moveTo(D[H][0],D[H][1],B)},setLeftTop:function(A,z){var y=this.dom.style;y.left=r.addUnits(A);y.top=r.addUnits(z);return this},getRegion:function(){return this.getPageBox(true)},getViewRegion:function(){var C=this,A=C.dom.nodeName==u,z,F,E,D,B,y;if(A){z=C.getScroll();D=z.left;E=z.top;B=Ext.dom.AbstractElement.getViewportWidth();y=Ext.dom.AbstractElement.getViewportHeight()}else{F=C.getXY();D=F[0]+C.getBorderWidth("l")+C.getPadding("l");E=F[1]+C.getBorderWidth("t")+C.getPadding("t");B=C.getWidth(true);y=C.getHeight(true)}return new Ext.util.Region(E,D+B-1,E+y-1,D)},setBounds:function(A,E,C,z,B){var D=this;if(!B||!D.anim){D.setSize(C,z);D.setLocation(A,E)}else{if(!Ext.isObject(B)){B={}}D.animate(Ext.applyIf({to:{x:A,y:E,width:D.adjustWidth(C),height:D.adjustHeight(z)}},B))}return D},setRegion:function(z,y){return this.setBounds(z.left,z.top,z.right-z.left,z.bottom-z.top,y)}})}());Ext.dom.Element.override({isScrollable:function(){var a=this.dom;return a.scrollHeight>a.clientHeight||a.scrollWidth>a.clientWidth},getScroll:function(){var i=this.dom,h=document,a=h.body,c=h.documentElement,b,g,e;if(i==h||i==a){if(Ext.isIE&&Ext.isStrict){b=c.scrollLeft;g=c.scrollTop}else{b=window.pageXOffset;g=window.pageYOffset}e={left:b||(a?a.scrollLeft:0),top:g||(a?a.scrollTop:0)}}else{e={left:i.scrollLeft,top:i.scrollTop}}return e},scrollBy:function(b,a,c){var d=this,e=d.dom;if(b.length){c=a;a=b[1];b=b[0]}else{if(typeof b!="number"){c=a;a=b.y;b=b.x}}if(b){d.scrollTo("left",Math.max(Math.min(e.scrollLeft+b,e.scrollWidth-e.clientWidth),0),c)}if(a){d.scrollTo("top",Math.max(Math.min(e.scrollTop+a,e.scrollHeight-e.clientHeight),0),c)}return d},scrollTo:function(c,e,a){var g=/top/i.test(c),d=this,h=d.dom,b,i;if(!a||!d.anim){i="scroll"+(g?"Top":"Left");h[i]=e;h[i]=e}else{b={to:{}};b.to["scroll"+(g?"Top":"Left")]=e;if(Ext.isObject(a)){Ext.applyIf(b,a)}d.animate(b)}return d},scrollIntoView:function(b,g,c){b=Ext.getDom(b)||Ext.getBody().dom;var d=this.dom,i=this.getOffsetsTo(b),h=i[0]+b.scrollLeft,l=i[1]+b.scrollTop,a=l+d.offsetHeight,m=h+d.offsetWidth,p=b.clientHeight,o=parseInt(b.scrollTop,10),e=parseInt(b.scrollLeft,10),j=o+p,n=e+b.clientWidth,k;if(d.offsetHeight>p||l<o){k=l}else{if(a>j){k=a-p}}if(k!=null){Ext.get(b).scrollTo("top",k,c)}if(g!==false){k=null;if(d.offsetWidth>b.clientWidth||h<e){k=h}else{if(m>n){k=m-b.clientWidth}}if(k!=null){Ext.get(b).scrollTo("left",k,c)}}return this},scrollChildIntoView:function(b,a){Ext.fly(b,"_scrollChildIntoView").scrollIntoView(this,a)},scroll:function(m,b,d){if(!this.isScrollable()){return false}var e=this.dom,g=e.scrollLeft,p=e.scrollTop,n=e.scrollWidth,k=e.scrollHeight,i=e.clientWidth,a=e.clientHeight,c=false,o,j={l:Math.min(g+b,n-i),r:o=Math.max(g-b,0),t:Math.max(p-b,0),b:Math.min(p+b,k-a)};j.d=j.b;j.u=j.t;m=m.substr(0,1);if((o=j[m])>-1){c=true;this.scrollTo(m=="l"||m=="r"?"left":"top",o,this.anim(d))}return c}});(function(){var p=Ext.dom.Element,m=document.defaultView,n=/table-row|table-.*-group/,a="_internal",r="hidden",o="height",g="width",e="isClipped",i="overflow",l="overflow-x",j="overflow-y",s="originalClip",b=/#document|body/i,t,d,q,h,u;if(!m||!m.getComputedStyle){p.prototype.getStyle=function(z,y){var L=this,G=L.dom,J=typeof z!="string",k=L.styleHooks,w=z,x=w,F=1,B=y,K,C,v,A,E,H,D;if(J){v={};w=x[0];D=0;if(!(F=x.length)){return v}}if(!G||G.documentElement){return v||""}C=G.style;if(y){H=C}else{H=G.currentStyle;if(!H){B=true;H=C}}do{A=k[w];if(!A){k[w]=A={name:p.normalize(w)}}if(A.get){E=A.get(G,L,B,H)}else{K=A.name;if(A.canThrow){try{E=H[K]}catch(I){E=""}}else{E=H?H[K]:""}}if(!J){return E}v[w]=E;w=x[++D]}while(D<F);return v}}p.override({getHeight:function(x,v){var w=this,z=w.dom,y=w.isStyle("display","none"),k,A;if(y){return 0}k=Math.max(z.offsetHeight,z.clientHeight)||0;if(Ext.supports.Direct2DBug){A=w.adjustDirect2DDimension(o);if(v){k+=A}else{if(A>0&&A<0.5){k++}}}if(x){k-=w.getBorderWidth("tb")+w.getPadding("tb")}return(k<0)?0:k},getWidth:function(k,z){var x=this,A=x.dom,y=x.isStyle("display","none"),w,v,B;if(y){return 0}if(Ext.supports.BoundingClientRect){w=A.getBoundingClientRect();v=w.right-w.left;v=z?v:Math.ceil(v)}else{v=A.offsetWidth}v=Math.max(v,A.clientWidth)||0;if(Ext.supports.Direct2DBug){B=x.adjustDirect2DDimension(g);if(z){v+=B}else{if(B>0&&B<0.5){v++}}}if(k){v-=x.getBorderWidth("lr")+x.getPadding("lr")}return(v<0)?0:v},setWidth:function(v,k){var w=this;v=w.adjustWidth(v);if(!k||!w.anim){w.dom.style.width=w.addUnits(v)}else{if(!Ext.isObject(k)){k={}}w.animate(Ext.applyIf({to:{width:v}},k))}return w},setHeight:function(k,v){var w=this;k=w.adjustHeight(k);if(!v||!w.anim){w.dom.style.height=w.addUnits(k)}else{if(!Ext.isObject(v)){v={}}w.animate(Ext.applyIf({to:{height:k}},v))}return w},applyStyles:function(k){Ext.DomHelper.applyStyles(this.dom,k);return this},setSize:function(w,k,v){var x=this;if(Ext.isObject(w)){v=k;k=w.height;w=w.width}w=x.adjustWidth(w);k=x.adjustHeight(k);if(!v||!x.anim){x.dom.style.width=x.addUnits(w);x.dom.style.height=x.addUnits(k)}else{if(v===true){v={}}x.animate(Ext.applyIf({to:{width:w,height:k}},v))}return x},getViewSize:function(){var w=this,x=w.dom,v=b.test(x.nodeName),k;if(v){k={width:p.getViewWidth(),height:p.getViewHeight()}}else{k={width:x.clientWidth,height:x.clientHeight}}return k},getSize:function(k){return{width:this.getWidth(k),height:this.getHeight(k)}},adjustWidth:function(k){var v=this,w=(typeof k=="number");if(w&&v.autoBoxAdjust&&!v.isBorderBox()){k-=(v.getBorderWidth("lr")+v.getPadding("lr"))}return(w&&k<0)?0:k},adjustHeight:function(k){var v=this,w=(typeof k=="number");if(w&&v.autoBoxAdjust&&!v.isBorderBox()){k-=(v.getBorderWidth("tb")+v.getPadding("tb"))}return(w&&k<0)?0:k},getColor:function(w,x,C){var z=this.getStyle(w),y=C||C===""?C:"#",B,k,A=0;if(!z||(/transparent|inherit/.test(z))){return x}if(/^r/.test(z)){z=z.slice(4,z.length-1).split(",");k=z.length;for(;A<k;A++){B=parseInt(z[A],10);y+=(B<16?"0":"")+B.toString(16)}}else{z=z.replace("#","");y+=z.length==3?z.replace(/^(\w)(\w)(\w)$/,"$1$1$2$2$3$3"):z}return(y.length>5?y.toLowerCase():x)},setOpacity:function(v,k){var w=this;if(!w.dom){return w}if(!k||!w.anim){w.setStyle("opacity",v)}else{if(typeof k!="object"){k={duration:350,easing:"ease-in"}}w.animate(Ext.applyIf({to:{opacity:v}},k))}return w},clearOpacity:function(){return this.setOpacity("")},adjustDirect2DDimension:function(w){var B=this,v=B.dom,z=B.getStyle("display"),y=v.style.display,C=v.style.position,A=w===g?0:1,k=v.currentStyle,x;if(z==="inline"){v.style.display="inline-block"}v.style.position=z.match(n)?"absolute":"static";x=(parseFloat(k[w])||parseFloat(k.msTransformOrigin.split(" ")[A])*2)%1;v.style.position=C;if(z==="inline"){v.style.display=y}return x},clip:function(){var v=this,w=(v.$cache||v.getCache()).data,k;if(!w[e]){w[e]=true;k=v.getStyle([i,l,j]);w[s]={o:k[i],x:k[l],y:k[j]};v.setStyle(i,r);v.setStyle(l,r);v.setStyle(j,r)}return v},unclip:function(){var v=this,w=(v.$cache||v.getCache()).data,k;if(w[e]){w[e]=false;k=w[s];if(k.o){v.setStyle(i,k.o)}if(k.x){v.setStyle(l,k.x)}if(k.y){v.setStyle(j,k.y)}}return v},boxWrap:function(k){k=k||Ext.baseCSSPrefix+"box";var v=Ext.get(this.insertHtml("beforeBegin","<div class='"+k+"'>"+Ext.String.format(p.boxMarkup,k)+"</div>"));Ext.DomQuery.selectNode("."+k+"-mc",v.dom).appendChild(this.dom);return v},getComputedHeight:function(){var v=this,k=Math.max(v.dom.offsetHeight,v.dom.clientHeight);if(!k){k=parseFloat(v.getStyle(o))||0;if(!v.isBorderBox()){k+=v.getFrameWidth("tb")}}return k},getComputedWidth:function(){var v=this,k=Math.max(v.dom.offsetWidth,v.dom.clientWidth);if(!k){k=parseFloat(v.getStyle(g))||0;if(!v.isBorderBox()){k+=v.getFrameWidth("lr")}}return k},getFrameWidth:function(v,k){return(k&&this.isBorderBox())?0:(this.getPadding(v)+this.getBorderWidth(v))},addClsOnOver:function(w,z,v){var x=this,y=x.dom,k=Ext.isFunction(z);x.hover(function(){if(k&&z.call(v||x,x)===false){return}Ext.fly(y,a).addCls(w)},function(){Ext.fly(y,a).removeCls(w)});return x},addClsOnFocus:function(w,z,v){var x=this,y=x.dom,k=Ext.isFunction(z);x.on("focus",function(){if(k&&z.call(v||x,x)===false){return false}Ext.fly(y,a).addCls(w)});x.on("blur",function(){Ext.fly(y,a).removeCls(w)});return x},addClsOnClick:function(w,z,v){var x=this,y=x.dom,k=Ext.isFunction(z);x.on("mousedown",function(){if(k&&z.call(v||x,x)===false){return false}Ext.fly(y,a).addCls(w);var B=Ext.getDoc(),A=function(){Ext.fly(y,a).removeCls(w);B.removeListener("mouseup",A)};B.on("mouseup",A)});return x},getStyleSize:function(){var z=this,A=this.dom,v=b.test(A.nodeName),y,k,x;if(v){return{width:p.getViewWidth(),height:p.getViewHeight()}}y=z.getStyle([o,g],true);if(y.width&&y.width!="auto"){k=parseFloat(y.width);if(z.isBorderBox()){k-=z.getFrameWidth("lr")}}if(y.height&&y.height!="auto"){x=parseFloat(y.height);if(z.isBorderBox()){x-=z.getFrameWidth("tb")}}return{width:k||z.getWidth(true),height:x||z.getHeight(true)}},selectable:function(){var k=this;k.dom.unselectable="off";k.on("selectstart",function(v){v.stopPropagation();return true});k.applyStyles("-moz-user-select: text; -khtml-user-select: text;");k.removeCls(Ext.baseCSSPrefix+"unselectable");return k},unselectable:function(){var k=this;k.dom.unselectable="on";k.swallowEvent("selectstart",true);k.applyStyles("-moz-user-select:-moz-none;-khtml-user-select:none;");k.addCls(Ext.baseCSSPrefix+"unselectable");return k}});p.prototype.styleHooks=t=Ext.dom.AbstractElement.prototype.styleHooks;if(Ext.isIE6||Ext.isIE7){t.fontSize=t["font-size"]={name:"fontSize",canThrow:true};t.fontStyle=t["font-style"]={name:"fontStyle",canThrow:true};t.fontFamily=t["font-family"]={name:"fontFamily",canThrow:true}}if(Ext.isIEQuirks||Ext.isIE&&Ext.ieVersion<=8){function c(x,v,w,k){if(k[this.styleName]=="none"){return"0px"}return k[this.name]}d=["Top","Right","Bottom","Left"];q=d.length;while(q--){h=d[q];u="border"+h+"Width";t["border-"+h.toLowerCase()+"-width"]=t[u]={name:u,styleName:"border"+h+"Style",get:c}}}}());Ext.onReady(function(){var c=/alpha\(opacity=(.*)\)/i,b=/^\s+|\s+$/g,a=Ext.dom.Element.prototype.styleHooks;a.opacity={name:"opacity",afterSet:function(g,e,d){if(d.isLayer){d.onOpacitySet(e)}}};if(!Ext.supports.Opacity&&Ext.isIE){Ext.apply(a.opacity,{get:function(h){var g=h.style.filter,e,d;if(g.match){e=g.match(c);if(e){d=parseFloat(e[1]);if(!isNaN(d)){return d?d/100:0}}}return 1},set:function(h,e){var d=h.style,g=d.filter.replace(c,"").replace(b,"");d.zoom=1;if(typeof(e)=="number"&&e>=0&&e<1){e*=100;d.filter=g+(g.length?" ":"")+"alpha(opacity="+e+")"}else{d.filter=g}}})}});Ext.dom.Element.override({select:function(a){return Ext.dom.Element.select(a,false,this.dom)}});Ext.define("Ext.dom.CompositeElementLite",{alternateClassName:"Ext.CompositeElementLite",requires:["Ext.dom.Element","Ext.dom.Query"],statics:{importElementMethods:function(){var b,c=Ext.dom.Element.prototype,a=this.prototype;for(b in c){if(typeof c[b]=="function"){(function(d){a[d]=a[d]||function(){return this.invoke(d,arguments)}}).call(a,b)}}}},constructor:function(b,a){this.elements=[];this.add(b,a);this.el=new Ext.dom.AbstractElement.Fly()},isComposite:true,getElement:function(a){return this.el.attach(a)},transformElement:function(a){return Ext.getDom(a)},getCount:function(){return this.elements.length},add:function(c,a){var e=this.elements,b,d;if(!c){return this}if(typeof c=="string"){c=Ext.dom.Element.selectorFunction(c,a)}else{if(c.isComposite){c=c.elements}else{if(!Ext.isIterable(c)){c=[c]}}}for(b=0,d=c.length;b<d;++b){e.push(this.transformElement(c[b]))}return this},invoke:function(d,a){var g=this.elements,e=g.length,c,b;d=Ext.dom.Element.prototype[d];for(b=0;b<e;b++){c=g[b];if(c){d.apply(this.getElement(c),a)}}return this},item:function(b){var c=this.elements[b],a=null;if(c){a=this.getElement(c)}return a},addListener:function(b,j,h,g){var d=this.elements,a=d.length,c,k;for(c=0;c<a;c++){k=d[c];if(k){Ext.EventManager.on(k,b,j,h||k,g)}}return this},each:function(g,d){var h=this,c=h.elements,a=c.length,b,j;for(b=0;b<a;b++){j=c[b];if(j){j=this.getElement(j);if(g.call(d||j,j,h,b)===false){break}}}return h},fill:function(a){var b=this;b.elements=[];b.add(a);return b},filter:function(b){var h=this,c=h.elements,g=c.length,d=[],e=0,j=typeof b=="function",k,a;for(;e<g;e++){a=c[e];k=false;if(a){a=h.getElement(a);if(j){k=b.call(a,a,h,e)!==false}else{k=a.is(b)}if(k){d.push(h.transformElement(a))}}}h.elements=d;return h},indexOf:function(a){return Ext.Array.indexOf(this.elements,this.transformElement(a))},replaceElement:function(e,c,a){var b=!isNaN(e)?e:this.indexOf(e),g;if(b>-1){c=Ext.getDom(c);if(a){g=this.elements[b];g.parentNode.insertBefore(c,g);Ext.removeNode(g)}Ext.Array.splice(this.elements,b,1,c)}return this},clear:function(){this.elements=[]},addElements:function(d,b){if(!d){return this}if(typeof d=="string"){d=Ext.dom.Element.selectorFunction(d,b)}var c=this.elements,a=d.length,g;for(g=0;g<a;g++){c.push(Ext.get(d[g]))}return this},first:function(){return this.item(0)},last:function(){return this.item(this.getCount()-1)},contains:function(a){return this.indexOf(a)!=-1},removeElement:function(e,i){e=[].concat(e);var d=this,g=d.elements,c=e.length,h,b,a;for(a=0;a<c;a++){h=e[a];if((b=(g[h]||g[h=d.indexOf(h)]))){if(i){if(b.dom){b.remove()}else{Ext.removeNode(b)}}Ext.Array.erase(g,h,1)}}return d}},function(){this.importElementMethods();this.prototype.on=this.prototype.addListener;if(Ext.DomQuery){Ext.dom.Element.selectorFunction=Ext.DomQuery.select}Ext.dom.Element.select=function(a,b){var c;if(typeof a=="string"){c=Ext.dom.Element.selectorFunction(a,b)}else{if(a.length!==undefined){c=a}else{}}return new Ext.CompositeElementLite(c)};Ext.select=function(){return Ext.dom.Element.select.apply(Ext.dom.Element,arguments)}});Ext.define("Ext.util.Animate",{requires:["Ext.Element","Ext.CompositeElementLite"],uses:["Ext.fx.Manager","Ext.fx.Anim"],animate:function(a){var b=this;if(Ext.fx.Manager.hasFxBlock(b.id)){return b}Ext.fx.Manager.queueFx(new Ext.fx.Anim(b.anim(a)));return this},anim:function(a){if(!Ext.isObject(a)){return(a)?{}:false}var b=this;if(a.stopAnimation){b.stopAnimation()}Ext.applyIf(a,Ext.fx.Manager.getFxDefaults(b.id));return Ext.apply({target:b,paused:true},a)},stopFx:Ext.Function.alias(Ext.util.Animate,"stopAnimation"),stopAnimation:function(){Ext.fx.Manager.stopAnimation(this.id);return this},syncFx:function(){Ext.fx.Manager.setFxDefaults(this.id,{concurrent:true});return this},sequenceFx:function(){Ext.fx.Manager.setFxDefaults(this.id,{concurrent:false});return this},hasActiveFx:Ext.Function.alias(Ext.util.Animate,"getActiveAnimation"),getActiveAnimation:function(){return Ext.fx.Manager.getActiveAnimation(this.id)}},function(){Ext.applyIf(Ext.Element.prototype,this.prototype);Ext.CompositeElementLite.importElementMethods()});Ext.define("Ext.util.ElementContainer",{childEls:[],constructor:function(){var b=this,a;if(b.hasOwnProperty("childEls")){a=b.childEls;delete b.childEls;b.addChildEls.apply(b,a)}},destroy:function(){var e=this,d=e.getChildEls(),g,a,c,b;for(c=d.length;c--;){a=d[c];if(typeof a!="string"){a=a.name}g=e[a];if(g){e[a]=null;g.remove()}}},addChildEls:function(){var b=this,a=arguments;if(b.hasOwnProperty("childEls")){b.childEls.push.apply(b.childEls,a)}else{b.childEls=b.getChildEls().concat(Array.prototype.slice.call(a))}b.prune(b.childEls,false)},applyChildEls:function(b,a){var e=this,g=e.getChildEls(),j,k,d,c,h;j=(a||e.id)+"-";for(d=g.length;d--;){k=g[d];if(typeof k=="string"){h=b.getById(j+k)}else{if((c=k.select)){h=Ext.select(c,true,b.dom)}else{if((c=k.selectNode)){h=Ext.get(Ext.DomQuery.selectNode(c,b.dom))}else{h=b.getById(k.id||(j+k.itemId))}}k=k.name}e[k]=h}},getChildEls:function(){var b=this,a;if(b.hasOwnProperty("childEls")){return b.childEls}a=b.self;return a.$childEls||b.getClassChildEls(a)},getClassChildEls:function(o){var k=this,p=o.$childEls,m,d,b,j,n,h,a,c,e,g,l;if(!p){g=o.superclass;if(g){g=g.self;c=[g.$childEls||k.getClassChildEls(g)];l=g.prototype.mixins||{}}else{c=[];l={}}e=o.prototype;h=e.mixins;for(a in h){if(h.hasOwnProperty(a)&&!l.hasOwnProperty(a)){n=h[a].self;c.push(n.$childEls||k.getClassChildEls(n))}}c.push(e.hasOwnProperty("childEls")&&e.childEls);for(d=0,b=c.length;d<b;++d){m=c[d];if(m&&m.length){if(!p){p=m}else{if(!j){j=true;p=p.slice(0)}p.push.apply(p,m)}}}o.$childEls=p=(p?k.prune(p,!j):[])}return p},prune:function(c,e){var b=c.length,d={},a;while(b--){a=c[b];if(typeof a!="string"){a=a.name}if(!d[a]){d[a]=1}else{if(e){e=false;c=c.slice(0)}Ext.Array.erase(c,b,1)}}return c},removeChildEls:function(g){var e=this,a=e.getChildEls(),d=(e.childEls=[]),h,b,c;for(b=0,h=a.length;b<h;++b){c=a[b];if(!g(c)){d.push(c)}}}});Ext.define("Ext.util.Renderable",{requires:["Ext.dom.Element"],frameCls:Ext.baseCSSPrefix+"frame",frameIdRegex:/[\-]frame\d+[TMB][LCR]$/,frameElementCls:{tl:[],tc:[],tr:[],ml:[],mc:[],mr:[],bl:[],bc:[],br:[]},frameElNames:["TL","TC","TR","ML","MC","MR","BL","BC","BR"],frameTpl:["{%this.renderDockedItems(out,values,0);%}",'<tpl if="top">','<tpl if="left"><div id="{fgid}TL" class="{frameCls}-tl {baseCls}-tl {baseCls}-{ui}-tl<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-tl</tpl>" style="background-position: {tl}; padding-left: {frameWidth}px" role="presentation"></tpl>','<tpl if="right"><div id="{fgid}TR" class="{frameCls}-tr {baseCls}-tr {baseCls}-{ui}-tr<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-tr</tpl>" style="background-position: {tr}; padding-right: {frameWidth}px" role="presentation"></tpl>','<div id="{fgid}TC" class="{frameCls}-tc {baseCls}-tc {baseCls}-{ui}-tc<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-tc</tpl>" style="background-position: {tc}; height: {frameWidth}px" role="presentation"></div>','<tpl if="right"></div></tpl>','<tpl if="left"></div></tpl>',"</tpl>",'<tpl if="left"><div id="{fgid}ML" class="{frameCls}-ml {baseCls}-ml {baseCls}-{ui}-ml<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-ml</tpl>" style="background-position: {ml}; padding-left: {frameWidth}px" role="presentation"></tpl>','<tpl if="right"><div id="{fgid}MR" class="{frameCls}-mr {baseCls}-mr {baseCls}-{ui}-mr<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-mr</tpl>" style="background-position: {mr}; padding-right: {frameWidth}px" role="presentation"></tpl>','<div id="{fgid}MC" class="{frameCls}-mc {baseCls}-mc {baseCls}-{ui}-mc<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-mc</tpl>" role="presentation">',"{%this.applyRenderTpl(out, values)%}","</div>",'<tpl if="right"></div></tpl>','<tpl if="left"></div></tpl>','<tpl if="bottom">','<tpl if="left"><div id="{fgid}BL" class="{frameCls}-bl {baseCls}-bl {baseCls}-{ui}-bl<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-bl</tpl>" style="background-position: {bl}; padding-left: {frameWidth}px" role="presentation"></tpl>','<tpl if="right"><div id="{fgid}BR" class="{frameCls}-br {baseCls}-br {baseCls}-{ui}-br<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-br</tpl>" style="background-position: {br}; padding-right: {frameWidth}px" role="presentation"></tpl>','<div id="{fgid}BC" class="{frameCls}-bc {baseCls}-bc {baseCls}-{ui}-bc<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-bc</tpl>" style="background-position: {bc}; height: {frameWidth}px" role="presentation"></div>','<tpl if="right"></div></tpl>','<tpl if="left"></div></tpl>',"</tpl>","{%this.renderDockedItems(out,values,1);%}"],frameTableTpl:["{%this.renderDockedItems(out,values,0);%}","<table><tbody>",'<tpl if="top">',"<tr>",'<tpl if="left"><td id="{fgid}TL" class="{frameCls}-tl {baseCls}-tl {baseCls}-{ui}-tl<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-tl</tpl>" style="background-position: {tl}; padding-left:{frameWidth}px" role="presentation"></td></tpl>','<td id="{fgid}TC" class="{frameCls}-tc {baseCls}-tc {baseCls}-{ui}-tc<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-tc</tpl>" style="background-position: {tc}; height: {frameWidth}px" role="presentation"></td>','<tpl if="right"><td id="{fgid}TR" class="{frameCls}-tr {baseCls}-tr {baseCls}-{ui}-tr<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-tr</tpl>" style="background-position: {tr}; padding-left: {frameWidth}px" role="presentation"></td></tpl>',"</tr>","</tpl>","<tr>",'<tpl if="left"><td id="{fgid}ML" class="{frameCls}-ml {baseCls}-ml {baseCls}-{ui}-ml<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-ml</tpl>" style="background-position: {ml}; padding-left: {frameWidth}px" role="presentation"></td></tpl>','<td id="{fgid}MC" class="{frameCls}-mc {baseCls}-mc {baseCls}-{ui}-mc<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-mc</tpl>" style="background-position: 0 0;" role="presentation">',"{%this.applyRenderTpl(out, values)%}","</td>",'<tpl if="right"><td id="{fgid}MR" class="{frameCls}-mr {baseCls}-mr {baseCls}-{ui}-mr<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-mr</tpl>" style="background-position: {mr}; padding-left: {frameWidth}px" role="presentation"></td></tpl>',"</tr>",'<tpl if="bottom">',"<tr>",'<tpl if="left"><td id="{fgid}BL" class="{frameCls}-bl {baseCls}-bl {baseCls}-{ui}-bl<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-bl</tpl>" style="background-position: {bl}; padding-left: {frameWidth}px" role="presentation"></td></tpl>','<td id="{fgid}BC" class="{frameCls}-bc {baseCls}-bc {baseCls}-{ui}-bc<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-bc</tpl>" style="background-position: {bc}; height: {frameWidth}px" role="presentation"></td>','<tpl if="right"><td id="{fgid}BR" class="{frameCls}-br {baseCls}-br {baseCls}-{ui}-br<tpl for="uiCls"> {parent.baseCls}-{parent.ui}-{.}-br</tpl>" style="background-position: {br}; padding-left: {frameWidth}px" role="presentation"></td></tpl>',"</tr>","</tpl>","</tbody></table>","{%this.renderDockedItems(out,values,1);%}"],afterRender:function(){var b=this,c={},e=b.protoEl,d=b.getTargetEl(),a;b.finishRenderChildren();if(b.styleHtmlContent){d.addCls(b.styleHtmlCls)}e.writeTo(c);a=c.removed;if(a){d.removeCls(a)}a=c.cls;if(a.length){d.addCls(a)}a=c.style;if(c.style){d.setStyle(a)}b.protoEl=null;if(!b.ownerCt){b.updateLayout()}},afterFirstLayout:function(d,a){var e=this,c=Ext.isDefined(e.x),b=Ext.isDefined(e.y),h,g;if(e.floating&&(!c||!b)){if(e.floatParent){h=e.floatParent.getTargetEl().getViewRegion();g=e.el.getAlignToXY(e.floatParent.getTargetEl(),"c-c");h.left=g[0]-h.left;h.top=g[1]-h.top}else{g=e.el.getAlignToXY(e.container,"c-c");h=e.container.translatePoints(g[0],g[1])}e.x=c?e.x:h.left;e.y=b?e.y:h.top;c=b=true}if(c||b){e.setPosition(e.x,e.y)}e.onBoxReady(d,a);if(e.hasListeners.boxready){e.fireEvent("boxready",e,d,a)}},onBoxReady:Ext.emptyFn,applyRenderSelectors:function(){var d=this,b=d.renderSelectors,c=d.el,e=c.dom,a;d.applyChildEls(c);if(b){for(a in b){if(b.hasOwnProperty(a)&&b[a]){d[a]=Ext.get(Ext.DomQuery.selectNode(b[a],e))}}}},beforeRender:function(){var b=this,c=b.getTargetEl(),a=b.getComponentLayout();b.frame=b.frame||b.alwaysFramed;if(!a.initialized){a.initLayout()}if(c){c.setStyle(b.getOverflowStyle());b.overflowStyleSet=true}b.setUI(b.ui);if(b.disabled){b.disable(true)}},doApplyRenderTpl:function(c,a){var d=a.$comp,b;if(!d.rendered){b=d.initRenderTpl();b.applyOut(a.renderData,c)}},doAutoRender:function(){var a=this;if(!a.rendered){if(a.floating){a.render(document.body)}else{a.render(Ext.isBoolean(a.autoRender)?Ext.getBody():a.autoRender)}}},doRenderContent:function(a,c){var b=c.$comp;if(b.html){Ext.DomHelper.generateMarkup(b.html,a);delete b.html}if(b.tpl){if(!b.tpl.isTemplate){b.tpl=new Ext.XTemplate(b.tpl)}if(b.data){b.tpl.applyOut(b.data,a);delete b.data}}},doRenderFramingDockedItems:function(a,c,d){var b=c.$comp;if(!b.rendered&&b.doRenderDockedItems){c.renderData.$skipDockedItems=true;b.doRenderDockedItems.call(this,a,c,d)}},finishRender:function(a){var g=this,b,h,e,d,i,c;if(!g.el||g.$pid){if(g.container){d=g.container.getById(g.id,true)}else{d=Ext.getDom(g.id)}if(!g.el){g.wrapPrimaryEl(d)}else{delete g.$pid;if(!g.el.dom){g.wrapPrimaryEl(g.el)}d.parentNode.insertBefore(g.el.dom,d);Ext.removeNode(d)}}else{if(!g.rendering){b=g.initRenderTpl();if(b){h=g.initRenderData();b.insertFirst(g.getTargetEl(),h)}}}if(!g.container){g.container=Ext.get(g.el.dom.parentNode)}if(g.ctCls){g.container.addCls(g.ctCls)}g.onRender(g.container,a);if(!g.overflowStyleSet){g.getTargetEl().setStyle(g.getOverflowStyle())}g.el.setVisibilityMode(Ext.Element[g.hideMode.toUpperCase()]);if(g.overCls){g.el.hover(g.addOverCls,g.removeOverCls,g)}if(g.hasListeners.render){g.fireEvent("render",g)}if(g.contentEl){i=Ext.baseCSSPrefix;c=i+"hide-";e=Ext.get(g.contentEl);e.removeCls([i+"hidden",c+"display",c+"offsets",c+"nosize"]);g.getTargetEl().appendChild(e.dom)}g.afterRender();if(g.hasListeners.afterrender){g.fireEvent("afterrender",g)}g.initEvents();if(g.hidden){g.el.hide()}},finishRenderChildren:function(){var a=this.getComponentLayout();a.finishRender()},getElConfig:function(){var h=this,j=h.autoEl,e=h.getFrameInfo(),a={tag:"div",tpl:e?h.initFramingTpl(e.table):h.initRenderTpl()},b,d,g,k,c;h.initStyles(h.protoEl);h.protoEl.writeTo(a);h.protoEl.flush();if(Ext.isString(j)){a.tag=j}else{Ext.apply(a,j)}a.id=h.id;if(a.tpl){if(e){d=h.frameElNames;g=d.length;c=h.id+"-frame1";h.frameGenId=1;a.tplData=Ext.apply({},{$comp:h,fgid:c,ui:h.ui,uiCls:h.uiCls,frameCls:h.frameCls,baseCls:h.baseCls,frameWidth:e.maxWidth,top:!!e.top,left:!!e.left,right:!!e.right,bottom:!!e.bottom,renderData:h.initRenderData()},h.getFramePositions(e));for(b=0;b<g;b++){k=d[b];h.addChildEls({name:"frame"+k,id:c+k})}h.addChildEls({name:"frameBody",id:c+"MC"})}else{a.tplData=h.initRenderData()}}return a},initFramingTpl:function(b){var a=b?this.getTpl("frameTableTpl"):this.getTpl("frameTpl");if(a&&!a.applyRenderTpl){this.setupFramingTpl(a)}return a},setupFramingTpl:function(a){a.applyRenderTpl=this.doApplyRenderTpl;a.renderDockedItems=this.doRenderFramingDockedItems},getInsertPosition:function(a){if(a!==undefined){if(Ext.isNumber(a)){a=this.container.dom.childNodes[a]}else{a=Ext.getDom(a)}}return a},getRenderTree:function(){var a=this;if(!a.hasListeners.beforerender||a.fireEvent("beforerender",a)!==false){a.beforeRender();a.rendering=true;if(a.el){return{tag:"div",id:(a.$pid=Ext.id())}}return a.getElConfig()}return null},initContainer:function(a){var b=this;if(!a&&b.el){a=b.el.dom.parentNode;b.allowDomMove=false}b.container=a.dom?a:Ext.get(a);return b.container},initRenderData:function(){var a=this;return Ext.apply({$comp:a,id:a.id,ui:a.ui,uiCls:a.uiCls,baseCls:a.baseCls,componentCls:a.componentCls,frame:a.frame},a.renderData)},initRenderTpl:function(){var a=this.getTpl("renderTpl");if(a&&!a.renderContent){this.setupRenderTpl(a)}return a},onRender:function(d,e){var h=this,j=h.x,i=h.y,c,a,k,b=h.el,g=Ext.getBody().dom;if(Ext.scopeResetCSS&&!h.ownerCt){if(b.dom===g){b.parent().addCls(Ext.resetCls)}else{if(h.floating&&h.el.dom.parentNode===g){Ext.resetElement.appendChild(h.el)}else{h.resetEl=b.wrap(Ext.resetElementSpec,false,Ext.supports.CSS3LinearGradient?undefined:"*")}}}h.applyRenderSelectors();delete h.rendering;h.rendered=true;c=null;if(j!==undefined){c=c||{};c.x=j}if(i!==undefined){c=c||{};c.y=i}if(!h.getFrameInfo()&&Ext.isBorderBox){a=h.width;k=h.height;if(typeof a=="number"){c=c||{};c.width=a}if(typeof k=="number"){c=c||{};c.height=k}}h.lastBox=h.el.lastBox=c},render:function(c,b){var e=this,d=e.el&&(e.el=Ext.get(e.el)),h,a,g;Ext.suspendLayouts();c=e.initContainer(c);g=e.getInsertPosition(b);if(!d){a=e.getRenderTree();if(e.ownerLayout&&e.ownerLayout.transformItemRenderTree){a=e.ownerLayout.transformItemRenderTree(a)}if(a){if(g){d=Ext.DomHelper.insertBefore(g,a)}else{d=Ext.DomHelper.append(c,a)}e.wrapPrimaryEl(d)}}else{if(!e.hasListeners.beforerender||e.fireEvent("beforerender",e)!==false){e.initStyles(d);if(e.allowDomMove!==false){if(g){c.dom.insertBefore(d.dom,g)}else{c.dom.appendChild(d.dom)}}}else{h=true}}if(d&&!h){e.finishRender(b)}Ext.resumeLayouts(!c.isDetachedBody)},ensureAttachedToBody:function(c){var b=this,a;while(b.ownerCt){b=b.ownerCt}if(b.container.isDetachedBody){b.container=a=Ext.resetElement;a.appendChild(b.el.dom);if(c){b.updateLayout()}if(typeof b.x=="number"||typeof b.y=="number"){b.setPosition(b.x,b.y)}}},setupRenderTpl:function(a){a.renderBody=a.renderContent=this.doRenderContent},wrapPrimaryEl:function(a){this.el=Ext.get(a,true)},initFrame:function(){if(Ext.supports.CSS3BorderRadius||!this.frame){return}var h=this,e=h.getFrameInfo(),j,a,c,b,d=h.frameElNames,g=d.length,k;if(e){j=e.maxWidth;a=h.getFrameTpl(e.table);h.frameGenId=c=(h.frameGenId||0)+1;c=h.id+"-frame"+c;a.insertFirst(h.el,Ext.apply({$comp:h,fgid:c,ui:h.ui,uiCls:h.uiCls,frameCls:h.frameCls,baseCls:h.baseCls,frameWidth:j,top:!!e.top,left:!!e.left,right:!!e.right,bottom:!!e.bottom},h.getFramePositions(e)));h.frameBody=h.el.down("."+h.frameCls+"-mc");h.removeChildEls(function(i){return i.id&&h.frameIdRegex.test(i.id)});for(b=0;b<g;b++){k=d[b];h["frame"+k]=h.el.getById(c+k)}}},updateFrame:function(){if(Ext.supports.CSS3BorderRadius||!this.frame){return}var e=this,h=this.frameSize&&this.frameSize.table,g=this.frameTL,d=this.frameBL,c=this.frameML,a=this.frameMC,b;this.initFrame();if(a){if(e.frame){b=this.frameMC.dom.className;a.insertAfter(this.frameMC);this.frameMC.remove();this.frameBody=this.frameMC=a;a.dom.className=b;if(h){e.el.query("> table")[1].remove()}else{if(g){g.remove()}if(d){d.remove()}if(c){c.remove()}}}}else{if(e.frame){this.applyRenderSelectors()}}},getFrameInfo:function(){if(Ext.supports.CSS3BorderRadius||!this.frame){return false}var g=this,i=g.frameInfoCache,a=g.el||g.protoEl,j=a.dom?a.dom.className:a.classList.join(" "),d=i[j],e,c,h,b;if(d==null){e=Ext.fly(g.getStyleProxy(j),"frame-style-el");c=e.getStyle("background-position-x");h=e.getStyle("background-position-y");if(!c&&!h){b=e.getStyle("background-position").split(" ");c=b[0];h=b[1]}d=g.calculateFrame(c,h);if(d){a.setStyle("background-image","none")}i[j]=d}g.frame=!!d;g.frameSize=d;return d},calculateFrame:function(h,g){if(!(parseInt(h,10)>=1000000&&parseInt(g,10)>=1000000)){return false}var a=Math.max,b=parseInt(h.substr(3,2),10),e=parseInt(h.substr(5,2),10),c=parseInt(g.substr(3,2),10),i=parseInt(g.substr(5,2),10),d={table:h.substr(0,3)=="110",vertical:g.substr(0,3)=="110",top:a(b,e),right:a(e,c),bottom:a(i,c),left:a(b,i)};d.maxWidth=a(d.top,d.right,d.bottom,d.left);d.width=d.left+d.right;d.height=d.top+d.bottom;return d},getStyleProxy:function(b){var a=this.styleProxyEl||(Ext.AbstractComponent.prototype.styleProxyEl=Ext.resetElement.createChild({style:{position:"absolute",top:"-10000px"}},null,true));a.className=b;return a},getFramePositions:function(e){var h=this,i=e.maxWidth,j=h.dock,d,b,g,c,a;if(e.vertical){b="0 -"+(i*0)+"px";g="0 -"+(i*1)+"px";if(j&&j=="right"){b="right -"+(i*0)+"px";g="right -"+(i*1)+"px"}d={tl:"0 -"+(i*0)+"px",tr:"0 -"+(i*1)+"px",bl:"0 -"+(i*2)+"px",br:"0 -"+(i*3)+"px",ml:"-"+(i*1)+"px 0",mr:"right 0",tc:b,bc:g}}else{c="-"+(i*0)+"px 0";a="right 0";if(j&&j=="bottom"){c="left bottom";a="right bottom"}d={tl:"0 -"+(i*2)+"px",tr:"right -"+(i*3)+"px",bl:"0 -"+(i*4)+"px",br:"right -"+(i*5)+"px",ml:c,mr:a,tc:"0 -"+(i*0)+"px",bc:"0 -"+(i*1)+"px"}}return d},getFrameTpl:function(a){return this.getTpl(a?"frameTableTpl":"frameTpl")},frameInfoCache:{}});Ext.define("Ext.state.Provider",{mixins:{observable:"Ext.util.Observable"},prefix:"ext-",constructor:function(a){a=a||{};var b=this;Ext.apply(b,a);b.addEvents("statechange");b.state={};b.mixins.observable.constructor.call(b)},get:function(b,a){return typeof this.state[b]=="undefined"?a:this.state[b]},clear:function(a){var b=this;delete b.state[a];b.fireEvent("statechange",b,a,null)},set:function(a,c){var b=this;b.state[a]=c;b.fireEvent("statechange",b,a,c)},decodeValue:function(g){var c=this,k=/^(a|n|d|b|s|o|e)\:(.*)$/,b=k.exec(unescape(g)),h,d,a,j,e,i;if(!b||!b[1]){return}d=b[1];g=b[2];switch(d){case"e":return null;case"n":return parseFloat(g);case"d":return new Date(Date.parse(g));case"b":return(g=="1");case"a":h=[];if(g!=""){j=g.split("^");e=j.length;for(i=0;i<e;i++){g=j[i];h.push(c.decodeValue(g))}}return h;case"o":h={};if(g!=""){j=g.split("^");e=j.length;for(i=0;i<e;i++){g=j[i];a=g.split("=");h[a[0]]=c.decodeValue(a[1])}}return h;default:return g}},encodeValue:function(e){var g="",d=0,b,a,c;if(e==null){return"e:1"}else{if(typeof e=="number"){b="n:"+e}else{if(typeof e=="boolean"){b="b:"+(e?"1":"0")}else{if(Ext.isDate(e)){b="d:"+e.toGMTString()}else{if(Ext.isArray(e)){for(a=e.length;d<a;d++){g+=this.encodeValue(e[d]);if(d!=a-1){g+="^"}}b="a:"+g}else{if(typeof e=="object"){for(c in e){if(typeof e[c]!="function"&&e[c]!==undefined){g+=c+"="+this.encodeValue(e[c])+"^"}}b="o:"+g.substring(0,g.length-1)}else{b="s:"+e}}}}}}return escape(b)}});Ext.define("Ext.state.Manager",{singleton:true,requires:["Ext.state.Provider"],constructor:function(){this.provider=new Ext.state.Provider()},setProvider:function(a){this.provider=a},get:function(b,a){return this.provider.get(b,a)},set:function(a,b){this.provider.set(a,b)},clear:function(a){this.provider.clear(a)},getProvider:function(){return this.provider}});Ext.define("Ext.state.Stateful",{mixins:{observable:"Ext.util.Observable"},requires:["Ext.state.Manager"],stateful:false,saveDelay:100,constructor:function(a){var b=this;a=a||{};if(a.stateful!==undefined){b.stateful=a.stateful}if(a.saveDelay!==undefined){b.saveDelay=a.saveDelay}b.stateId=b.stateId||a.stateId;if(!b.stateEvents){b.stateEvents=[]}if(a.stateEvents){b.stateEvents.concat(a.stateEvents)}this.addEvents("beforestaterestore","staterestore","beforestatesave","statesave");b.mixins.observable.constructor.call(b);if(b.stateful!==false){b.addStateEvents(b.stateEvents);b.initState()}},addStateEvents:function(c){var e=this,b,d,a;if(e.stateful&&e.getStateId()){if(typeof c=="string"){c=Array.prototype.slice.call(arguments,0)}a=e.stateEventsByName||(e.stateEventsByName={});for(b=c.length;b--;){d=c[b];if(!a[d]){a[d]=1;e.on(d,e.onStateChange,e)}}}},onStateChange:function(){var c=this,a=c.saveDelay,d,b;if(!c.stateful){return}if(a){if(!c.stateTask){d=Ext.state.Stateful;b=d.runner||(d.runner=new Ext.util.TaskRunner());c.stateTask=b.newTask({run:c.saveState,scope:c,interval:a,repeat:1})}c.stateTask.start()}else{c.saveState()}},saveState:function(){var b=this,d=b.stateful&&b.getStateId(),a=b.hasListeners,c;if(d){c=b.getState()||{};if(!a.beforestatesave||b.fireEvent("beforestatesave",b,c)!==false){Ext.state.Manager.set(d,c);if(a.statesave){b.fireEvent("statesave",b,c)}}}},getState:function(){return null},applyState:function(a){if(a){Ext.apply(this,a)}},getStateId:function(){var a=this;return a.stateId||(a.autoGenId?null:a.id)},initState:function(){var b=this,d=b.stateful&&b.getStateId(),a=b.hasListeners,c;if(d){c=Ext.state.Manager.get(d);if(c){c=Ext.apply({},c);if(!a.beforestaterestore||b.fireEvent("beforestaterestore",b,c)!==false){b.applyState(c);if(a.staterestore){b.fireEvent("staterestore",b,c)}}}}},savePropToState:function(g,e,d){var b=this,c=b[g],a=b.initialConfig;if(b.hasOwnProperty(g)){if(!a||a[g]!==c){if(e){e[d||g]=c}return true}}return false},savePropsToState:function(e,c){var b=this,a,d;if(typeof e=="string"){b.savePropToState(e,c)}else{for(a=0,d=e.length;a<d;++a){b.savePropToState(e[a],c)}}return c},destroy:function(){var b=this,a=b.stateTask;if(a){a.destroy();b.stateTask=null}b.clearListeners()}});Ext.define("Ext.AbstractComponent",{requires:["Ext.ComponentQuery","Ext.ComponentManager","Ext.util.ProtoElement"],mixins:{observable:"Ext.util.Observable",animate:"Ext.util.Animate",elementCt:"Ext.util.ElementContainer",renderable:"Ext.util.Renderable",state:"Ext.state.Stateful"},uses:["Ext.PluginManager","Ext.Element","Ext.DomHelper","Ext.XTemplate","Ext.ComponentQuery","Ext.ComponentLoader","Ext.EventManager","Ext.layout.Context","Ext.layout.Layout","Ext.layout.component.Auto","Ext.LoadMask","Ext.ZIndexManager"],statics:{AUTO_ID:1000,pendingLayouts:null,layoutSuspendCount:0,cancelLayout:function(a,c){var b=this.runningLayoutContext||this.pendingLayouts;if(b){b.cancelComponent(a,false,c)}},flushLayouts:function(){var b=this,a=b.pendingLayouts;if(a&&a.invalidQueue.length){b.pendingLayouts=null;b.runningLayoutContext=a;Ext.override(a,{runComplete:function(){b.runningLayoutContext=null;return this.callParent()}});a.run()}},resumeLayouts:function(a){if(this.layoutSuspendCount&&!--this.layoutSuspendCount){if(a){this.flushLayouts()}}},suspendLayouts:function(){++this.layoutSuspendCount},updateLayout:function(b,e){var c=this,a=c.runningLayoutContext,d;if(a){a.queueInvalidate(b)}else{d=c.pendingLayouts||(c.pendingLayouts=new Ext.layout.Context());d.queueInvalidate(b);if(!e&&!c.layoutSuspendCount&&!b.isLayoutSuspended()){c.flushLayouts()}}}},isComponent:true,getAutoId:function(){this.autoGenId=true;return ++Ext.AbstractComponent.AUTO_ID},deferLayouts:false,autoGenId:false,renderTpl:"{%this.renderContent(out,values)%}",frameSize:{left:0,top:0,right:0,bottom:0,width:0,height:0},tplWriteMode:"overwrite",baseCls:Ext.baseCSSPrefix+"component",disabledCls:Ext.baseCSSPrefix+"item-disabled",ui:"default",uiCls:[],hidden:false,disabled:false,draggable:false,floating:false,hideMode:"display",styleHtmlContent:false,styleHtmlCls:Ext.baseCSSPrefix+"html",autoShow:false,autoRender:false,allowDomMove:true,rendered:false,componentLayoutCounter:0,shrinkWrap:2,weight:0,maskOnDisable:true,_isLayoutRoot:false,constructor:function(c){var e=this,d,a,b;if(c){Ext.apply(e,c);b=e.xhooks;if(b){delete e.xhooks;Ext.override(e,b)}}else{c={}}e.initialConfig=c;e.mixins.elementCt.constructor.call(e);e.addEvents("beforeactivate","activate","beforedeactivate","deactivate","added","disable","enable","beforeshow","show","beforehide","hide","removed","beforerender","render","afterrender","boxready","beforedestroy","destroy","resize","move","focus","blur");e.getId();e.setupProtoEl();if(e.cls){e.initialCls=e.cls;e.protoEl.addCls(e.cls)}if(e.style){e.initialStyle=e.style;e.protoEl.setStyle(e.style)}e.mons=[];e.renderData=e.renderData||{};e.renderSelectors=e.renderSelectors||{};if(e.plugins){e.plugins=e.constructPlugins()}if(!e.hasListeners){e.hasListeners=new e.HasListeners()}e.initComponent();Ext.ComponentManager.register(e);e.mixins.observable.constructor.call(e);e.mixins.state.constructor.call(e,c);this.addStateEvents("resize");if(e.plugins){for(d=0,a=e.plugins.length;d<a;d++){e.plugins[d]=e.initPlugin(e.plugins[d])}}e.loader=e.getLoader();if(e.renderTo){e.render(e.renderTo)}if(e.autoShow&&!e.isContained){e.show()}},initComponent:function(){this.plugins=this.constructPlugins();this.setSize(this.width,this.height)},getState:function(){var b=this,c=null,a=b.getSizeModel();if(a.width.configured){c=b.addPropertyToState(c,"width")}if(a.height.configured){c=b.addPropertyToState(c,"height")}return c},addPropertyToState:function(e,d,c){var b=this,a=arguments.length;if(a==3||b.hasOwnProperty(d)){if(a<3){c=b[d]}if(c!==b.initialConfig[d]){(e||(e={}))[d]=c}}return e},show:Ext.emptyFn,animate:function(b){var k=this,e,g,d,p,o,m,l,j,n,i,c,a;b=b||{};o=b.to||{};if(Ext.fx.Manager.hasFxBlock(k.id)){return k}e=Ext.isDefined(o.width);if(e){p=Ext.Number.constrain(o.width,k.minWidth,k.maxWidth)}g=Ext.isDefined(o.height);if(g){d=Ext.Number.constrain(o.height,k.minHeight,k.maxHeight)}if(!b.dynamic&&(e||g)){j=(b.from?b.from.width:undefined)||k.getWidth();n=j;i=(b.from?b.from.height:undefined)||k.getHeight();c=i;a=false;if(g&&d>i){c=d;a=true}if(e&&p>j){n=p;a=true}if(a){m=!Ext.isNumber(k.width);l=!Ext.isNumber(k.height);k.setSize(n,c);k.el.setSize(j,i);if(m){delete k.width}if(l){delete k.height}}if(e){o.width=p}if(g){o.height=d}}return k.mixins.animate.animate.apply(k,arguments)},onHide:function(){this.updateLayout({isRoot:false})},onShow:function(){this.updateLayout({isRoot:false})},constructPlugin:function(a){if(a.ptype&&typeof a.init!="function"){a.cmp=this;a=Ext.PluginManager.create(a)}else{if(typeof a=="string"){a=Ext.PluginManager.create({ptype:a,cmp:this})}}return a},constructPlugins:function(){var e=this,c,b=[],d,a;if(e.plugins){c=Ext.isArray(e.plugins)?e.plugins:[e.plugins];for(d=0,a=c.length;d<a;d++){b[d]=e.constructPlugin(c[d])}return b}},initPlugin:function(a){a.init(this);return a},updateAria:Ext.emptyFn,registerFloatingItem:function(b){var a=this;if(!a.floatingDescendants){a.floatingDescendants=new Ext.ZIndexManager(a)}a.floatingDescendants.register(b)},unregisterFloatingItem:function(b){var a=this;if(a.floatingDescendants){a.floatingDescendants.unregister(b)}},layoutSuspendCount:0,suspendLayouts:function(){var a=this;if(!a.rendered){return}if(++a.layoutSuspendCount==1){a.suspendLayout=true}},resumeLayouts:function(b){var a=this;if(!a.rendered){return}if(!--a.layoutSuspendCount){a.suspendLayout=false;if(b&&!a.isLayoutSuspended()){a.updateLayout(b)}}},setupProtoEl:function(){var b=this,a=[b.baseCls,b.getComponentLayout().targetCls];if(Ext.isDefined(b.cmpCls)){if(Ext.isDefined(Ext.global.console)){Ext.global.console.warn("Ext.Component: cmpCls has been deprecated. Please use componentCls.")}b.componentCls=b.cmpCls;delete b.cmpCls}if(b.componentCls){a.push(b.componentCls)}else{b.componentCls=b.baseCls}b.protoEl=new Ext.util.ProtoElement({cls:a.join(" ")})},setUI:function(g){var e=this,b=Ext.Array.clone(e.uiCls),h=[],d=[],a,c;for(c=0;c<b.length;c++){a=b[c];d=d.concat(e.removeClsWithUI(a,true));h.push(a)}if(d.length){e.removeCls(d)}e.removeUIFromElement();e.ui=g;e.addUIToElement();d=[];for(c=0;c<h.length;c++){a=h[c];d=d.concat(e.addClsWithUI(a,true))}if(d.length){e.addCls(d)}if(e.rendered){e.updateLayout()}},addClsWithUI:function(c,h){var g=this,e=[],d,b=0,a;if(typeof c==="string"){c=(c.indexOf(" ")<0)?[c]:Ext.String.splitWords(c)}d=c.length;g.uiCls=Ext.Array.clone(g.uiCls);for(;b<d;b++){a=c[b];if(a&&!g.hasUICls(a)){g.uiCls.push(a);e=e.concat(g.addUIClsToElement(a))}}if(h!==true){g.addCls(e)}return e},removeClsWithUI:function(c,h){var g=this,e=[],b=0,d,a;if(typeof c==="string"){c=(c.indexOf(" ")<0)?[c]:Ext.String.splitWords(c)}d=c.length;for(b=0;b<d;b++){a=c[b];if(a&&g.hasUICls(a)){g.uiCls=Ext.Array.remove(g.uiCls,a);e=e.concat(g.removeUIClsFromElement(a))}}if(h!==true){g.removeCls(e)}return e},hasUICls:function(a){var b=this,c=b.uiCls||[];return Ext.Array.contains(c,a)},frameElementsArray:["tl","tc","tr","ml","mc","mr","bl","bc","br"],addUIClsToElement:function(m){var k=this,b=k.baseCls+"-"+k.ui+"-"+m,n=[Ext.baseCSSPrefix+m,k.baseCls+"-"+m,b],l=k.frameElementCls,h,g,e,a,d,j;if(k.frame&&!Ext.supports.CSS3BorderRadius){h=k.frameElementsArray;g=h.length;e=0;for(;e<g;e++){d=h[e];a=k["frame"+d.toUpperCase()];j=b+"-"+d;if(a&&a.dom){a.addCls(j)}else{if(Ext.Array.indexOf(l[d],j)==-1){l[d].push(j)}}}}k.frameElementCls=l;return n},removeUIClsFromElement:function(m){var k=this,b=k.baseCls+"-"+k.ui+"-"+m,n=[Ext.baseCSSPrefix+m,k.baseCls+"-"+m,b],l=k.frameElementCls,h,g,e,a,d,j;if(k.frame&&!Ext.supports.CSS3BorderRadius){h=k.frameElementsArray;g=h.length;e=0;for(;e<g;e++){d=h[e];a=k["frame"+d.toUpperCase()];j=b+"-"+d;if(a&&a.dom){a.addCls(j)}else{Ext.Array.remove(l[d],j)}}}k.frameElementCls=l;return n},addUIToElement:function(){var j=this,k=j.baseCls+"-"+j.ui,l=j.frameElementCls,g,e,d,a,b,h;j.addCls(k);if(j.frame&&!Ext.supports.CSS3BorderRadius){g=j.frameElementsArray;e=g.length;d=0;for(;d<e;d++){b=g[d];a=j["frame"+b.toUpperCase()];h=k+"-"+b;if(a){a.addCls(h)}else{if(!Ext.Array.contains(l[b],h)){l[b].push(h)}}}}},removeUIFromElement:function(){var j=this,k=j.baseCls+"-"+j.ui,l=j.frameElementCls,g,e,d,a,b,h;j.removeCls(k);if(j.frame&&!Ext.supports.CSS3BorderRadius){g=j.frameElementsArray;e=g.length;d=0;for(;d<e;d++){b=g[d];a=j["frame"+b.toUpperCase()];h=k+"-"+b;if(a){a.removeCls(h)}else{Ext.Array.remove(l[b],h)}}}},getTpl:function(a){return Ext.XTemplate.getTpl(this,a)},initStyles:function(j){var d=this,b=Ext.Element,g=d.padding,c=d.margin,h=d.x,e=d.y,a,i;if(g!==undefined){j.setStyle("padding",b.unitizeBox((g===true)?5:g))}if(c!==undefined){j.setStyle("margin",b.unitizeBox((c===true)?5:c))}if(d.border!==undefined){d.setBorder(d.border,j)}if(d.cls&&d.cls!=d.initialCls){j.addCls(d.cls);delete d.cls;delete d.initialCls}if(d.style&&d.style!=d.initialStyle){j.setStyle(d.style);delete d.style;delete d.initialStyle}if(h!==undefined){j.setStyle("left",(typeof h=="number")?(h+"px"):h)}if(e!==undefined){j.setStyle("top",(typeof e=="number")?(e+"px"):e)}if(!d.getFrameInfo()){a=d.width;i=d.height;if(a!==undefined){if(typeof a==="number"){if(Ext.isBorderBox){j.setStyle("width",a+"px")}}else{j.setStyle("width",a)}}if(i!==undefined){if(typeof i==="number"){if(Ext.isBorderBox){j.setStyle("height",i+"px")}}else{j.setStyle("height",i)}}}},initEvents:function(){var c=this,e=c.afterRenderEvents,b,d,a=function(g){c.mon(b,g)};if(e){for(d in e){if(e.hasOwnProperty(d)){b=c[d];if(b&&b.on){Ext.each(e[d],a)}}}}c.addFocusListener()},addFocusListener:function(){var c=this,b=c.getFocusEl(),a;if(b){if(b.isComponent){return b.addFocusListener()}a=b.needsTabIndex();if(!c.focusListenerAdded&&(!a||Ext.FocusManager.enabled)){if(a){b.dom.tabIndex=-1}b.on({focus:c.onFocus,blur:c.onBlur,scope:c});c.focusListenerAdded=true}}},getFocusEl:Ext.emptyFn,isFocusable:function(d){var b=this,a;if((b.focusable!==false)&&(a=b.getFocusEl())&&b.rendered&&!b.destroying&&!b.isDestroyed&&!b.disabled&&b.isVisible(true)){if(a.isComponent){return a.isFocusable()}return a&&a.dom&&a.isVisible()}},preFocus:Ext.emptyFn,onFocus:function(d){var c=this,b=c.focusCls,a=c.getFocusEl();if(!c.disabled){c.preFocus(d);if(b&&a){a.addCls(c.addClsWithUI(b,true))}if(!c.hasFocus){c.hasFocus=true;c.fireEvent("focus",c,d)}}},beforeBlur:Ext.emptyFn,onBlur:function(d){var c=this,b=c.focusCls,a=c.getFocusEl();if(c.destroying){return}c.beforeBlur(d);if(b&&a){a.removeCls(c.removeClsWithUI(b,true))}if(c.validateOnBlur){c.validate()}c.hasFocus=false;c.fireEvent("blur",c,d);c.postBlur(d)},postBlur:Ext.emptyFn,is:function(a){return Ext.ComponentQuery.is(this,a)},up:function(b){var a=this.getBubbleTarget();if(b){for(;a;a=a.getBubbleTarget()){if(Ext.ComponentQuery.is(a,b)){return a}}}return a},nextSibling:function(b){var g=this.ownerCt,d,e,a,h;if(g){d=g.items;a=d.indexOf(this)+1;if(a){if(b){for(e=d.getCount();a<e;a++){if((h=d.getAt(a)).is(b)){return h}}}else{if(a<d.getCount()){return d.getAt(a)}}}}return null},previousSibling:function(b){var e=this.ownerCt,d,a,g;if(e){d=e.items;a=d.indexOf(this);if(a!=-1){if(b){for(--a;a>=0;a--){if((g=d.getAt(a)).is(b)){return g}}}else{if(a){return d.getAt(--a)}}}}return null},previousNode:function(b,d){var j=this,h=j.ownerCt,a,g,e,c;if(d&&j.is(b)){return j}if(h){for(g=h.items.items,e=Ext.Array.indexOf(g,j)-1;e>-1;e--){c=g[e];if(c.query){a=c.query(b);a=a[a.length-1];if(a){return a}}if(c.is(b)){return c}}return h.previousNode(b,true)}return null},nextNode:function(d,j){var b=this,c=b.ownerCt,k,e,h,g,a;if(j&&b.is(d)){return b}if(c){for(e=c.items.items,g=Ext.Array.indexOf(e,b)+1,h=e.length;g<h;g++){a=e[g];if(a.is(d)){return a}if(a.down){k=a.down(d);if(k){return k}}}return c.nextNode(d)}return null},getId:function(){return this.id||(this.id="ext-comp-"+(this.getAutoId()))},getItemId:function(){return this.itemId||this.id},getEl:function(){return this.el},getTargetEl:function(){return this.frameBody||this.el},getOverflowStyle:function(){var b=this,a=null;if(typeof b.autoScroll=="boolean"){a={overflow:b.autoScroll?"auto":""}}else{if(b.overflowX!==undefined||b.overflowY!==undefined){a={"overflow-x":(b.overflowX||""),"overflow-y":(b.overflowY||"")}}}if(a&&(Ext.isIE6||Ext.isIE7)){a.position="relative"}return a},isXType:function(b,a){if(a){return this.xtype===b}else{return this.xtypesMap[b]}},getXTypes:function(){var c=this.self,d,b,a;if(!c.xtypes){d=[];b=this;while(b){a=b.xtypes;if(a!==undefined){d.unshift.apply(d,a)}b=b.superclass}c.xtypeChain=d;c.xtypes=d.join("/")}return c.xtypes},update:function(b,c,a){var d=this;if(d.tpl&&!Ext.isString(b)){d.data=b;if(d.rendered){d.tpl[d.tplWriteMode](d.getTargetEl(),b||{})}}else{d.html=Ext.isObject(b)?Ext.DomHelper.markup(b):b;if(d.rendered){d.getTargetEl().update(d.html,c,a)}}if(d.rendered){d.updateLayout()}},setVisible:function(a){return this[a?"show":"hide"]()},isVisible:function(a){var c=this,e=c,d=c.rendered&&!c.hidden,b=c.ownerCt;c.hiddenAncestor=false;if(c.destroyed){return false}if(a&&d&&b){while(b){if(b.hidden||(b.collapsed&&!(b.getDockedItems&&Ext.Array.contains(b.getDockedItems(),e)))){c.hiddenAncestor=b;d=false;break}e=b;b=b.ownerCt}}return d},onBoxReady:function(){var a=this;if(a.disableOnBoxReady){a.onDisable()}else{if(a.enableOnBoxReady){a.onEnable()}}if(a.resizable){a.initResizable(a.resizable)}if(a.draggable){a.initDraggable()}},enable:function(a){var b=this;delete b.disableOnBoxReady;b.removeCls(b.disabledCls);if(b.rendered){b.onEnable()}else{b.enableOnBoxReady=true}b.disabled=false;delete b.resetDisable;if(a!==true){b.fireEvent("enable",b)}return b},disable:function(a){var b=this;delete b.enableOnBoxReady;b.addCls(b.disabledCls);if(b.rendered){b.onDisable()}else{b.disableOnBoxReady=true}b.disabled=true;if(a!==true){delete b.resetDisable;b.fireEvent("disable",b)}return b},onEnable:function(){if(this.maskOnDisable){this.el.dom.disabled=false;this.unmask()}},onDisable:function(){var c=this,b=c.focusCls,a=c.getFocusEl();if(b&&a){a.removeCls(c.removeClsWithUI(b,true))}if(c.maskOnDisable){c.el.dom.disabled=true;c.mask()}},mask:function(){var b=this.lastBox,c=this.getMaskTarget(),a=[];if(b){a[2]=b.height}c.mask.apply(c,a)},unmask:function(){this.getMaskTarget().unmask()},getMaskTarget:function(){return this.el},isDisabled:function(){return this.disabled},setDisabled:function(a){return this[a?"disable":"enable"]()},isHidden:function(){return this.hidden},addCls:function(a){var c=this,b=c.rendered?c.el:c.protoEl;b.addCls.apply(b,arguments);return c},addClass:function(){return this.addCls.apply(this,arguments)},hasCls:function(a){var c=this,b=c.rendered?c.el:c.protoEl;return b.hasCls.apply(b,arguments)},removeCls:function(a){var c=this,b=c.rendered?c.el:c.protoEl;b.removeCls.apply(b,arguments);return c},addOverCls:function(){var a=this;if(!a.disabled){a.el.addCls(a.overCls)}},removeOverCls:function(){this.el.removeCls(this.overCls)},addListener:function(b,g,e,a){var h=this,d,c;if(Ext.isString(b)&&(Ext.isObject(g)||a&&a.element)){if(a.element){d=g;g={};g[b]=d;b=a.element;if(e){g.scope=e}for(c in a){if(a.hasOwnProperty(c)){if(h.eventOptionsRe.test(c)){g[c]=a[c]}}}}if(h[b]&&h[b].on){h.mon(h[b],g)}else{h.afterRenderEvents=h.afterRenderEvents||{};if(!h.afterRenderEvents[b]){h.afterRenderEvents[b]=[]}h.afterRenderEvents[b].push(g)}}return h.mixins.observable.addListener.apply(h,arguments)},removeManagedListenerItem:function(b,a,i,d,g,e){var h=this,c=a.options?a.options.element:null;if(c){c=h[c];if(c&&c.un){if(b||(a.item===i&&a.ename===d&&(!g||a.fn===g)&&(!e||a.scope===e))){c.un(a.ename,a.fn,a.scope);if(!b){Ext.Array.remove(h.managedListeners,a)}}}}else{return h.mixins.observable.removeManagedListenerItem.apply(h,arguments)}},getBubbleTarget:function(){return this.ownerCt},isFloating:function(){return this.floating},isDraggable:function(){return !!this.draggable},isDroppable:function(){return !!this.droppable},onAdded:function(a,c){var b=this;b.ownerCt=a;if(b.hasListeners.added){b.fireEvent("added",b,a,c)}},onRemoved:function(b){var a=this;if(a.hasListeners.removed){a.fireEvent("removed",a,a.ownerCt)}delete a.ownerCt;delete a.ownerLayout},beforeDestroy:Ext.emptyFn,onResize:Ext.emptyFn,setSize:function(b,a){var c=this;if(b&&typeof b=="object"){a=b.height;b=b.width}if(typeof b=="number"){c.width=Ext.Number.constrain(b,c.minWidth,c.maxWidth)}else{if(b===null){delete c.width}}if(typeof a=="number"){c.height=Ext.Number.constrain(a,c.minHeight,c.maxHeight)}else{if(a===null){delete c.height}}if(c.rendered&&c.isVisible()){c.updateLayout({isRoot:false})}return c},isLayoutRoot:function(){var a=this,b=a.ownerLayout;if(!b||a._isLayoutRoot||a.floating){return true}return b.isItemLayoutRoot(a)},isLayoutSuspended:function(){var a=this,b;while(a){if(a.layoutSuspendCount||a.suspendLayout){return true}b=a.ownerLayout;if(!b){break}a=b.owner}return false},updateLayout:function(b){var c=this,d,a=b&&b.isRoot;if(!c.rendered||c.layoutSuspendCount||c.suspendLayout){return}if(c.hidden){Ext.AbstractComponent.cancelLayout(c)}else{if(typeof a!="boolean"){a=c.isLayoutRoot()}}if(a||!c.ownerLayout||!c.ownerLayout.onContentChange(c)){if(!c.isLayoutSuspended()){d=(b&&b.hasOwnProperty("defer"))?b.defer:c.deferLayouts;Ext.AbstractComponent.updateLayout(c,d)}}},getSizeModel:function(j){var n=this,a=Ext.layout.SizeModel,d=n.componentLayout.ownerContext,b=n.width,p=n.height,q,c,g,e,h,o,l,m,k,i;if(d){i=d.widthModel;h=d.heightModel}if(!i||!h){g=((q=typeof b)=="number");e=((c=typeof p)=="number");k=n.floating||!(o=n.ownerLayout);if(k){l=Ext.layout.Layout.prototype.autoSizePolicy;m=n.floating?3:n.shrinkWrap;if(g){i=a.configured}if(e){h=a.configured}}else{l=o.getItemSizePolicy(n,j);m=o.isItemShrinkWrap(n)}m=(m===true)?3:(m||0);if(k&&m){if(b&&q=="string"){m&=2}if(p&&c=="string"){m&=1}}if(m!==3){if(!j){j=n.ownerCt&&n.ownerCt.getSizeModel()}if(j){m|=(j.width.shrinkWrap?1:0)|(j.height.shrinkWrap?2:0)}}if(!i){if(!l.setsWidth){if(g){i=a.configured}else{i=(m&1)?a.shrinkWrap:a.natural}}else{if(l.readsWidth){if(g){i=a.calculatedFromConfigured}else{i=(m&1)?a.calculatedFromShrinkWrap:a.calculatedFromNatural}}else{i=a.calculated}}}if(!h){if(!l.setsHeight){if(e){h=a.configured}else{h=(m&2)?a.shrinkWrap:a.natural}}else{if(l.readsHeight){if(e){h=a.calculatedFromConfigured}else{h=(m&2)?a.calculatedFromShrinkWrap:a.calculatedFromNatural}}else{h=a.calculated}}}}return i.pairsByHeightOrdinal[h.ordinal]},isDescendant:function(a){if(a.isContainer){for(var b=this.ownerCt;b;b=b.ownerCt){if(b===a){return true}}}return false},doComponentLayout:function(){this.updateLayout();return this},forceComponentLayout:function(){this.updateLayout()},setComponentLayout:function(b){var a=this.componentLayout;if(a&&a.isLayout&&a!=b){a.setOwner(null)}this.componentLayout=b;b.setOwner(this)},getComponentLayout:function(){var a=this;if(!a.componentLayout||!a.componentLayout.isLayout){a.setComponentLayout(Ext.layout.Layout.create(a.componentLayout,"autocomponent"))}return a.componentLayout},afterComponentLayout:function(a,k,b,j){var g=this,h,d,c,e;if(++g.componentLayoutCounter===1){g.afterFirstLayout(a,k)}if(g.floatingItems){h=g.floatingItems.items;d=h.length;for(c=0;c<d;c++){e=h[c];if(!e.rendered&&e.autoShow){e.show()}}}if(g.hasListeners.resize&&(a!==b||k!==j)){g.fireEvent("resize",g,a,k,b,j)}},beforeComponentLayout:function(b,a){return true},setPosition:function(a,e,b){var c=this,d=c.beforeSetPosition.apply(c,arguments);if(d&&c.rendered){d=c.convertPosition(d);if(d.left!==c.el.getLeft()||d.top!==c.el.getTop()){if(b){c.stopAnimation();c.animate(Ext.apply({duration:1000,listeners:{afteranimate:Ext.Function.bind(c.afterSetPosition,c,[d.left,d.top])},to:d},b))}else{if(d.left!==undefined&&d.top!==undefined){c.el.setLeftTop(d.left,d.top)}else{if(d.left!==undefined){c.el.setLeft(d.left)}else{if(d.top!==undefined){c.el.setTop(d.top)}}}c.afterSetPosition(d.left,d.top)}}}return c},beforeSetPosition:function(a,e,b){var d,c;if(!a||Ext.isNumber(a)){d={x:a,y:e,anim:b}}else{if(Ext.isNumber(c=a[0])){d={x:c,y:a[1],anim:e}}else{d={x:a.x,y:a.y,anim:e}}}d.hasX=Ext.isNumber(d.x);d.hasY=Ext.isNumber(d.y);this.x=d.x;this.y=d.y;return(d.hasX||d.hasY)?d:null},afterSetPosition:function(a,c){var b=this;b.onPosition(a,c);if(b.hasListeners.move){b.fireEvent("move",b,a,c)}},convertPosition:function(d,b){var a={},c=Ext.Element;if(d.hasX){a.left=b?c.addUnits(d.x):d.x}if(d.hasY){a.top=b?c.addUnits(d.y):d.y}return a},onPosition:Ext.emptyFn,setWidth:function(a){return this.setSize(a)},setHeight:function(a){return this.setSize(undefined,a)},getSize:function(){return this.el.getSize()},getWidth:function(){return this.el.getWidth()},getHeight:function(){return this.el.getHeight()},getLoader:function(){var c=this,b=c.autoLoad?(Ext.isObject(c.autoLoad)?c.autoLoad:{url:c.autoLoad}):null,a=c.loader||b;if(a){if(!a.isLoader){c.loader=new Ext.ComponentLoader(Ext.apply({target:c,autoLoad:b},a))}else{a.setTarget(c)}return c.loader}return null},setDocked:function(b,c){var a=this;a.dock=b;if(c&&a.ownerCt&&a.rendered){a.ownerCt.updateLayout()}return a},setBorder:function(b,d){var c=this,a=!!d;if(c.rendered||a){if(!a){d=c.el}if(!b){b=0}else{b=Ext.Element.unitizeBox((b===true)?1:b)}d.setStyle("border-width",b);if(!a){c.updateLayout()}}c.border=b},onDestroy:function(){var a=this;if(a.monitorResize&&Ext.EventManager.resizeEvent){Ext.EventManager.resizeEvent.removeListener(a.setSize,a)}Ext.destroy(a.componentLayout,a.loadMask,a.floatingDescendants)},destroy:function(){var d=this,b=d.renderSelectors,a,c;if(!d.isDestroyed){if(!d.hasListeners.beforedestroy||d.fireEvent("beforedestroy",d)!==false){d.destroying=true;d.beforeDestroy();if(d.floating){delete d.floatParent;if(d.zIndexManager){d.zIndexManager.unregister(d)}}else{if(d.ownerCt&&d.ownerCt.remove){d.ownerCt.remove(d,false)}}d.onDestroy();Ext.destroy(d.plugins);if(d.hasListeners.destroy){d.fireEvent("destroy",d)}Ext.ComponentManager.unregister(d);d.mixins.state.destroy.call(d);d.clearListeners();if(d.rendered){if(!d.preserveElOnDestroy){d.el.remove()}d.mixins.elementCt.destroy.call(d);if(b){for(a in b){if(b.hasOwnProperty(a)){c=d[a];if(c){delete d[a];c.remove()}}}}delete d.el;delete d.frameBody;delete d.rendered}d.destroying=false;d.isDestroyed=true}}},getPlugin:function(b){var c=0,a=this.plugins,d=a.length;for(;c<d;c++){if(a[c].pluginId===b){return a[c]}}},isDescendantOf:function(a){return !!this.findParentBy(function(b){return b===a})}},function(){var a=this;a.createAlias({on:"addListener",prev:"previousSibling",next:"nextSibling"});Ext.resumeLayouts=function(b){a.resumeLayouts(b)};Ext.suspendLayouts=function(){a.suspendLayouts()};Ext.batchLayouts=function(c,b){a.suspendLayouts();c.call(b);a.resumeLayouts(true)}});Ext.define("Ext.AbstractPlugin",{disabled:false,constructor:function(a){this.initialConfig=a;Ext.apply(this,a)},clone:function(){return new this.self(this.initialConfig)},getCmp:function(){return this.cmp},init:Ext.emptyFn,destroy:Ext.emptyFn,enable:function(){this.disabled=false},disable:function(){this.disabled=true}});Ext.define("Ext.Action",{constructor:function(a){this.initialConfig=a;this.itemId=a.itemId=(a.itemId||a.id||Ext.id());this.items=[]},isAction:true,setText:function(a){this.initialConfig.text=a;this.callEach("setText",[a])},getText:function(){return this.initialConfig.text},setIconCls:function(a){this.initialConfig.iconCls=a;this.callEach("setIconCls",[a])},getIconCls:function(){return this.initialConfig.iconCls},setDisabled:function(a){this.initialConfig.disabled=a;this.callEach("setDisabled",[a])},enable:function(){this.setDisabled(false)},disable:function(){this.setDisabled(true)},isDisabled:function(){return this.initialConfig.disabled},setHidden:function(a){this.initialConfig.hidden=a;this.callEach("setVisible",[!a])},show:function(){this.setHidden(false)},hide:function(){this.setHidden(true)},isHidden:function(){return this.initialConfig.hidden},setHandler:function(b,a){this.initialConfig.handler=b;this.initialConfig.scope=a;this.callEach("setHandler",[b,a])},each:function(b,a){Ext.each(this.items,b,a)},callEach:function(g,c){var b=this.items,d=0,a=b.length,e;Ext.suspendLayouts();for(;d<a;d++){e=b[d];e[g].apply(e,c)}Ext.resumeLayouts(true)},addComponent:function(a){this.items.push(a);a.on("destroy",this.removeComponent,this)},removeComponent:function(a){Ext.Array.remove(this.items,a)},execute:function(){this.initialConfig.handler.apply(this.initialConfig.scope||Ext.global,arguments)}});Ext.define("Ext.data.Connection",{mixins:{observable:"Ext.util.Observable"},statics:{requestId:0},url:null,async:true,method:null,username:"",password:"",disableCaching:true,withCredentials:false,cors:false,disableCachingParam:"_dc",timeout:30000,useDefaultHeader:true,defaultPostHeader:"application/x-www-form-urlencoded; charset=UTF-8",useDefaultXhrHeader:true,defaultXhrHeader:"XMLHttpRequest",constructor:function(a){a=a||{};Ext.apply(this,a);this.requests={};this.mixins.observable.constructor.call(this)},request:function(k){k=k||{};var g=this,j=k.scope||window,e=k.username||g.username,h=k.password||g.password||"",b,c,d,a,i;if(g.fireEvent("beforerequest",g,k)!==false){c=g.setOptions(k,j);if(g.isFormUpload(k)){g.upload(k.form,c.url,c.data,k);return null}if(k.autoAbort||g.autoAbort){g.abort()}b=k.async!==false?(k.async||g.async):false;i=g.openRequest(k,c,b,e,h);a=g.setupHeaders(i,k,c.data,c.params);d={id:++Ext.data.Connection.requestId,xhr:i,headers:a,options:k,async:b,timeout:setTimeout(function(){d.timedout=true;g.abort(d)},k.timeout||g.timeout)};g.requests[d.id]=d;g.latestId=d.id;if(b){i.onreadystatechange=Ext.Function.bind(g.onStateChange,g,[d])}i.send(c.data);if(!b){return g.onComplete(d)}return d}else{Ext.callback(k.callback,k.scope,[k,undefined,undefined]);return null}},upload:function(b,g,s,e){b=Ext.getDom(b);e=e||{};var n=Ext.id(),l=document.createElement("iframe"),c=[],d="multipart/form-data",r={target:b.target,method:b.method,encoding:b.encoding,enctype:b.enctype,action:b.action},a=function(h,u){i=document.createElement("input");Ext.fly(i).set({type:"hidden",value:u,name:h});b.appendChild(i);c.push(i)},i,k,p,t,o,j,m,q;Ext.fly(l).set({id:n,name:n,cls:Ext.baseCSSPrefix+"hide-display",src:Ext.SSL_SECURE_URL});document.body.appendChild(l);if(document.frames){document.frames[n].name=n}Ext.fly(b).set({target:n,method:"POST",enctype:d,encoding:d,action:g||r.action});if(s){k=Ext.Object.fromQueryString(s)||{};for(t in k){if(k.hasOwnProperty(t)){p=k[t];if(Ext.isArray(p)){o=p.length;for(j=0;j<o;j++){a(t,p[j])}}else{a(t,p)}}}}Ext.fly(l).on("load",Ext.Function.bind(this.onUploadComplete,this,[l,e]),null,{single:true});b.submit();Ext.fly(b).set(r);m=c.length;for(q=0;q<m;q++){Ext.removeNode(c[q])}},onUploadComplete:function(i,c){var d=this,b={responseText:"",responseXML:null},h,a;try{h=i.contentWindow.document||i.contentDocument||window.frames[i.id].document;if(h){if(h.body){if((a=h.body.firstChild)&&/pre/i.test(a.tagName)){b.responseText=a.innerText}else{if(a=h.getElementsByTagName("textarea")[0]){b.responseText=a.value}else{b.responseText=h.body.textContent||h.body.innerText}}}b.responseXML=h.XMLDocument||h}}catch(g){}d.fireEvent("requestcomplete",d,b,c);Ext.callback(c.success,c.scope,[b,c]);Ext.callback(c.callback,c.scope,[c,true,b]);setTimeout(function(){Ext.removeNode(i)},100)},isFormUpload:function(a){var b=this.getForm(a);if(b){return(a.isUpload||(/multipart\/form-data/i).test(b.getAttribute("enctype")))}return false},getForm:function(a){return Ext.getDom(a.form)||null},setOptions:function(l,k){var i=this,e=l.params||{},h=i.extraParams,d=l.urlParams,c=l.url||i.url,j=l.jsonData,b,a,g;if(Ext.isFunction(e)){e=e.call(k,l)}if(Ext.isFunction(c)){c=c.call(k,l)}c=this.setupUrl(l,c);g=l.rawData||l.xmlData||j||null;if(j&&!Ext.isPrimitive(j)){g=Ext.encode(g)}if(Ext.isObject(e)){e=Ext.Object.toQueryString(e)}if(Ext.isObject(h)){h=Ext.Object.toQueryString(h)}e=e+((h)?((e)?"&":"")+h:"");d=Ext.isObject(d)?Ext.Object.toQueryString(d):d;e=this.setupParams(l,e);b=(l.method||i.method||((e||g)?"POST":"GET")).toUpperCase();this.setupMethod(l,b);a=l.disableCaching!==false?(l.disableCaching||i.disableCaching):false;if(b==="GET"&&a){c=Ext.urlAppend(c,(l.disableCachingParam||i.disableCachingParam)+"="+(new Date().getTime()))}if((b=="GET"||g)&&e){c=Ext.urlAppend(c,e);e=null}if(d){c=Ext.urlAppend(c,d)}return{url:c,method:b,data:g||e||null}},setupUrl:function(b,a){var c=this.getForm(b);if(c){a=a||c.action}return a},setupParams:function(a,d){var c=this.getForm(a),b;if(c&&!this.isFormUpload(a)){b=Ext.Element.serializeForm(c);d=d?(d+"&"+b):b}return d},setupMethod:function(a,b){if(this.isFormUpload(a)){return"POST"}return b},setupHeaders:function(m,n,d,c){var i=this,b=Ext.apply({},n.headers||{},i.defaultHeaders||{}),l=i.defaultPostHeader,j=n.jsonData,a=n.xmlData,k,g;if(!b["Content-Type"]&&(d||c)){if(d){if(n.rawData){l="text/plain"}else{if(a&&Ext.isDefined(a)){l="text/xml"}else{if(j&&Ext.isDefined(j)){l="application/json"}}}}b["Content-Type"]=l}if(i.useDefaultXhrHeader&&!b["X-Requested-With"]){b["X-Requested-With"]=i.defaultXhrHeader}try{for(k in b){if(b.hasOwnProperty(k)){g=b[k];m.setRequestHeader(k,g)}}}catch(h){i.fireEvent("exception",k,g)}return b},newRequest:function(a){var b;if((a.cors||this.cors)&&Ext.isIE&&Ext.ieVersion>=8){b=new XDomainRequest()}else{b=this.getXhrInstance()}return b},openRequest:function(c,a,d,g,b){var e=this.newRequest(c);if(g){e.open(a.method,a.url,d,g,b)}else{e.open(a.method,a.url,d)}if(c.withCredentials||this.withCredentials){e.withCredentials=true}return e},getXhrInstance:(function(){var b=[function(){return new XMLHttpRequest()},function(){return new ActiveXObject("MSXML2.XMLHTTP.3.0")},function(){return new ActiveXObject("MSXML2.XMLHTTP")},function(){return new ActiveXObject("Microsoft.XMLHTTP")}],c=0,a=b.length,g;for(;c<a;++c){try{g=b[c];g();break}catch(d){}}return g}()),isLoading:function(a){if(!a){a=this.getLatest()}if(!(a&&a.xhr)){return false}var b=a.xhr.readyState;return !(b===0||b==4)},abort:function(b){var a=this,d;if(!b){b=a.getLatest()}if(b&&a.isLoading(b)){d=b.xhr;try{d.onreadystatechange=null}catch(c){d=Ext.emptyFn}d.abort();a.clearTimeout(b);if(!b.timedout){b.aborted=true}a.onComplete(b);a.cleanup(b)}},abortAll:function(){var b=this.requests,a;for(a in b){if(b.hasOwnProperty(a)){this.abort(b[a])}}},getLatest:function(){var b=this.latestId,a;if(b){a=this.requests[b]}return a||null},onStateChange:function(a){if(a.xhr.readyState==4){this.clearTimeout(a);this.onComplete(a);this.cleanup(a)}},clearTimeout:function(a){clearTimeout(a.timeout);delete a.timeout},cleanup:function(a){a.xhr=null;delete a.xhr},onComplete:function(g){var d=this,c=g.options,a,i,b;try{a=d.parseStatus(g.xhr.status)}catch(h){a={success:false,isException:false}}i=a.success;if(i){b=d.createResponse(g);d.fireEvent("requestcomplete",d,b,c);Ext.callback(c.success,c.scope,[b,c])}else{if(a.isException||g.aborted||g.timedout){b=d.createException(g)}else{b=d.createResponse(g)}d.fireEvent("requestexception",d,b,c);Ext.callback(c.failure,c.scope,[b,c])}Ext.callback(c.callback,c.scope,[c,i,b]);delete d.requests[g.id];return b},parseStatus:function(a){a=a==1223?204:a;var c=(a>=200&&a<300)||a==304,b=false;if(!c){switch(a){case 12002:case 12029:case 12030:case 12031:case 12152:case 13030:b=true;break}}return{success:c,isException:b}},createResponse:function(c){var i=c.xhr,a={},j=i.getAllResponseHeaders().replace(/\r\n/g,"\n").split("\n"),d=j.length,k,e,h,g,b;while(d--){k=j[d];e=k.indexOf(":");if(e>=0){h=k.substr(0,e).toLowerCase();if(k.charAt(e+1)==" "){++e}a[h]=k.substr(e+1)}}c.xhr=null;delete c.xhr;b={request:c,requestId:c.id,status:i.status,statusText:i.statusText,getResponseHeader:function(l){return a[l.toLowerCase()]},getAllResponseHeaders:function(){return a},responseText:i.responseText,responseXML:i.responseXML};i=null;return b},createException:function(a){return{request:a,requestId:a.id,status:a.aborted?-1:0,statusText:a.aborted?"transaction aborted":"communication failure",aborted:a.aborted,timedout:a.timedout}}});Ext.define("Ext.Ajax",{extend:"Ext.data.Connection",singleton:true,autoAbort:false});Ext.define("Ext.util.Floating",{uses:["Ext.Layer","Ext.window.Window"],focusOnToFront:true,shadow:"sides",constructor:function(b){var a=this;a.el=new Ext.Layer(Ext.apply({hideMode:a.hideMode,hidden:a.hidden,shadow:(typeof a.shadow!="undefined")?a.shadow:"sides",shadowOffset:a.shadowOffset,constrain:false,shim:(a.shim===false)?false:undefined},a.floating),b);a.floating=true;a.registerWithOwnerCt()},registerWithOwnerCt:function(){var a=this;if(a.zIndexParent){a.zIndexParent.unregisterFloatingItem(a)}a.zIndexParent=a.up("[floating]");a.setFloatParent(a.ownerCt);delete a.ownerCt;if(a.zIndexParent){a.zIndexParent.registerFloatingItem(a)}else{Ext.WindowManager.register(a)}},setFloatParent:function(b){var a=this;if(a.floatParent){a.mun(a.floatParent,{hide:a.onFloatParentHide,show:a.onFloatParentShow,scope:a})}a.floatParent=b;if(b){a.mon(a.floatParent,{hide:a.onFloatParentHide,show:a.onFloatParentShow,scope:a})}if((a.constrain||a.constrainHeader)&&!a.constrainTo){a.constrainTo=b?b.getTargetEl():a.container}},onAfterFloatLayout:function(){this.syncShadow()},onFloatParentHide:function(){var a=this;if(a.hideOnParentHide!==false&&a.isVisible()){a.hide();a.showOnParentShow=true}},onFloatParentShow:function(){if(this.showOnParentShow){delete this.showOnParentShow;this.show()}},setZIndex:function(a){var b=this;b.el.setZIndex(a);a+=10;if(b.floatingDescendants){a=Math.floor(b.floatingDescendants.setBase(a)/100)*100+10000}return a},doConstrain:function(b){var c=this,a=c.getConstrainVector(b),d;if(a){d=c.getPosition(!!c.floatParent);d[0]+=a[0];d[1]+=a[1];c.setPosition(d)}},getConstrainVector:function(a){var b=this;if(b.constrain||b.constrainHeader){a=a||(b.floatParent&&b.floatParent.getTargetEl())||b.container||b.el.getScopeParent();return(b.constrainHeader?b.header.el:b.el).getConstrainVector(a)}},alignTo:function(b,a,c){this.setPagePosition(this.el.getAlignToXY(b.el||b,a,c));return this},toFront:function(b){var a=this;if(a.zIndexParent&&a.bringParentToFront!==false){a.zIndexParent.toFront(true)}if(!Ext.isDefined(b)){b=!a.focusOnToFront}if(b){a.preventFocusOnActivate=true}if(a.zIndexManager.bringToFront(a)){if(!b){a.focus(false,true)}}delete a.preventFocusOnActivate;return a},setActive:function(b,c){var a=this;if(b){if(a.el.shadow&&!a.maximized){a.el.enableShadow(true)}if(a.modal&&!a.preventFocusOnActivate){a.focus(false,true)}a.fireEvent("activate",a)}else{if(a.isWindow&&(c&&c.isWindow)){a.el.disableShadow()}a.fireEvent("deactivate",a)}},toBack:function(){this.zIndexManager.sendToBack(this);return this},center:function(){var a=this,b;if(a.isVisible()){b=a.el.getAlignToXY(a.container,"c-c");a.setPagePosition(b)}else{a.needsCenter=true}return a},onFloatShow:function(){if(this.needsCenter){this.center()}delete this.needsCenter},syncShadow:function(){if(this.floating){this.el.sync(true)}},fitContainer:function(){var c=this,b=c.floatParent,a=b?b.getTargetEl():c.container;c.setSize(a.getViewSize(false));c.setPosition.apply(c,b?[0,0]:a.getXY())}});Ext.define("Ext.Component",{alias:["widget.component","widget.box"],extend:"Ext.AbstractComponent",requires:["Ext.util.DelayedTask"],uses:["Ext.Layer","Ext.resizer.Resizer","Ext.util.ComponentDragger"],mixins:{floating:"Ext.util.Floating"},statics:{DIRECTION_TOP:"top",DIRECTION_RIGHT:"right",DIRECTION_BOTTOM:"bottom",DIRECTION_LEFT:"left",VERTICAL_DIRECTION_Re:/^(?:top|bottom)$/,INVALID_ID_CHARS_Re:/[\.,\s]/g},resizeHandles:"all",floating:false,toFrontOnShow:true,hideMode:"display",bubbleEvents:[],monPropRe:/^(?:scope|delay|buffer|single|stopEvent|preventDefault|stopPropagation|normalized|args|delegate)$/,defaultComponentLayoutType:"autocomponent",constructor:function(a){var b=this;a=a||{};if(a.initialConfig){if(a.isAction){b.baseAction=a}a=a.initialConfig}else{if(a.tagName||a.dom||Ext.isString(a)){a={applyTo:a,id:a.id||a}}}b.callParent([a]);if(b.baseAction){b.baseAction.addComponent(b)}},initComponent:function(){var a=this;a.callParent();if(a.listeners){a.on(a.listeners);a.listeners=null}a.enableBubble(a.bubbleEvents);a.mons=[]},afterRender:function(){var a=this;a.callParent();if(!(a.x&&a.y)&&(a.pageX||a.pageY)){a.setPagePosition(a.pageX,a.pageY)}},setAutoScroll:function(a){var b=this;b.autoScroll=!!a;if(b.rendered){b.getTargetEl().setStyle(b.getOverflowStyle())}b.updateLayout();return b},setOverflowXY:function(b,a){var c=this,d=arguments.length;if(d){c.overflowX=b||"";if(d>1){c.overflowY=a||""}}if(c.rendered){c.getTargetEl().setStyle(c.getOverflowStyle())}c.updateLayout();return c},beforeRender:function(){var b=this,c=b.floating,a;if(c){b.addCls(Ext.baseCSSPrefix+"layer");a=c.cls;if(a){b.addCls(a)}}return b.callParent()},afterComponentLayout:function(){this.callParent(arguments);if(this.floating){this.onAfterFloatLayout()}},makeFloating:function(a){this.mixins.floating.constructor.call(this,a)},wrapPrimaryEl:function(a){if(this.floating){this.makeFloating(a)}else{this.callParent(arguments)}},initResizable:function(a){var b=this;a=Ext.apply({target:b,dynamic:false,constrainTo:b.constrainTo||(b.floatParent?b.floatParent.getTargetEl():null),handles:b.resizeHandles},a);a.target=b;b.resizer=new Ext.resizer.Resizer(a)},getDragEl:function(){return this.el},initDraggable:function(){var c=this,a=(c.resizer&&c.resizer.el!==c.el)?c.resizerComponent=new Ext.Component({el:c.resizer.el,rendered:true,container:c.container}):c,b=Ext.applyIf({el:a.getDragEl(),constrainTo:c.constrain?(c.constrainTo||(c.floatParent?c.floatParent.getTargetEl():c.el.getScopeParent())):undefined},c.draggable);if(c.constrain||c.constrainDelegate){b.constrain=c.constrain;b.constrainDelegate=c.constrainDelegate}c.dd=new Ext.util.ComponentDragger(a,b)},scrollBy:function(b,a,c){var d;if((d=this.getTargetEl())&&d.dom){d.scrollBy.apply(d,arguments)}},setLoading:function(c,d){var b=this,a;if(b.rendered){Ext.destroy(b.loadMask);b.loadMask=null;if(c!==false&&!b.collapsed){if(Ext.isObject(c)){a=Ext.apply({},c)}else{if(Ext.isString(c)){a={msg:c}}else{a={}}}if(d){Ext.applyIf(a,{useTargetEl:true})}b.loadMask=new Ext.LoadMask(b,a);b.loadMask.show()}}return b.loadMask},beforeSetPosition:function(){var b=this,c=b.callParent(arguments),a;if(c){a=b.adjustPosition(c.x,c.y);c.x=a.x;c.y=a.y}return c||null},afterSetPosition:function(b,a){this.onPosition(b,a);this.fireEvent("move",this,b,a)},showAt:function(a,d,b){var c=this;if(!c.rendered&&(c.autoRender||c.floating)){c.doAutoRender();c.hidden=true}if(c.floating){c.setPosition(a,d,b)}else{c.setPagePosition(a,d,b)}c.show()},setPagePosition:function(a,g,b){var c=this,d,e;if(Ext.isArray(a)){g=a[1];a=a[0]}c.pageX=a;c.pageY=g;if(c.floating){if(c.isContainedFloater()){e=c.floatParent.getTargetEl().getViewRegion();if(Ext.isNumber(a)&&Ext.isNumber(e.left)){a-=e.left}if(Ext.isNumber(g)&&Ext.isNumber(e.top)){g-=e.top}}else{d=c.el.translatePoints(a,g);a=d.left;g=d.top}c.setPosition(a,g,b)}else{d=c.el.translatePoints(a,g);c.setPosition(d.left,d.top,b)}return c},isContainedFloater:function(){return(this.floating&&this.floatParent)},getBox:function(b){var c=b?this.getPosition(b):this.el.getXY(),a=this.getSize();a.x=c[0];a.y=c[1];return a},updateBox:function(a){this.setSize(a.width,a.height);this.setPagePosition(a.x,a.y);return this},getOuterSize:function(){var a=this.el;return{width:a.getWidth()+a.getMargin("lr"),height:a.getHeight()+a.getMargin("tb")}},adjustPosition:function(a,d){var b=this,c;if(b.isContainedFloater()){c=b.floatParent.getTargetEl().getViewRegion();a+=c.left;d+=c.top}return{x:a,y:d}},getPosition:function(a){var c=this,b=c.el,e,d=c.isContainedFloater(),g;if((a===true)&&!d){return[b.getLocalX(),b.getLocalY()]}e=c.el.getXY();if((a===true)&&d){g=c.floatParent.getTargetEl().getViewRegion();e[0]-=g.left;e[1]-=g.top}return e},getId:function(){var a=this,b;if(!a.id){b=a.getXType();if(b){b=b.replace(Ext.Component.INVALID_ID_CHARS_Re,"-")}else{b=Ext.name.toLowerCase()+"-comp"}a.id=b+"-"+a.getAutoId()}return a.id},show:function(d,a,b){var c=this,e=c.rendered;if(e&&c.isVisible()){if(c.toFrontOnShow&&c.floating){c.toFront()}}else{if(c.fireEvent("beforeshow",c)!==false){c.hidden=false;if(!e&&(c.autoRender||c.floating)){c.doAutoRender();e=c.rendered}if(e){c.beforeShow();c.onShow.apply(c,arguments);c.afterShow.apply(c,arguments)}}else{c.onShowVeto()}}return c},onShowVeto:Ext.emptyFn,beforeShow:Ext.emptyFn,onShow:function(){var a=this;a.el.show();a.callParent(arguments);if(a.floating){if(a.maximized){a.fitContainer()}else{if(a.constrain){a.doConstrain()}}}},afterShow:function(h,b,e){var g=this,a,c,d;h=h||g.animateTarget;if(!g.ghost){h=null}if(h){h=h.el?h.el:Ext.get(h);c=g.el.getBox();a=h.getBox();g.el.addCls(Ext.baseCSSPrefix+"hide-offsets");d=g.ghost();d.el.stopAnimation();d.el.setX(-10000);d.el.animate({from:a,to:c,listeners:{afteranimate:function(){delete d.componentLayout.lastComponentSize;g.unghost();g.el.removeCls(Ext.baseCSSPrefix+"hide-offsets");g.onShowComplete(b,e)}}})}else{g.onShowComplete(b,e)}},onShowComplete:function(a,b){var c=this;if(c.floating){c.toFront();c.onFloatShow()}Ext.callback(a,b||c);c.fireEvent("show",c);delete c.hiddenByLayout},hide:function(){var a=this;a.showOnParentShow=false;if(!(a.rendered&&!a.isVisible())&&a.fireEvent("beforehide",a)!==false){a.hidden=true;if(a.rendered){a.onHide.apply(a,arguments)}}return a},onHide:function(g,a,d){var e=this,c,b;g=g||e.animateTarget;if(!e.ghost){g=null}if(g){g=g.el?g.el:Ext.get(g);c=e.ghost();c.el.stopAnimation();b=g.getBox();b.width+="px";b.height+="px";c.el.animate({to:b,listeners:{afteranimate:function(){delete c.componentLayout.lastComponentSize;c.el.hide();e.afterHide(a,d)}}})}e.el.hide();if(!g){e.afterHide(a,d)}},afterHide:function(a,b){var c=this;delete c.hiddenByLayout;Ext.AbstractComponent.prototype.onHide.call(this);Ext.callback(a,b||c);c.fireEvent("hide",c)},onDestroy:function(){var a=this;if(a.rendered){Ext.destroy(a.proxy,a.proxyWrap,a.resizer,a.resizerComponent)}delete a.focusTask;a.callParent()},deleteMembers:function(){var b=arguments,a=b.length,c=0;for(;c<a;++c){delete this[b[c]]}},focus:function(e,c){var d=this,a,g,b;if(c){if(!d.focusTask){d.focusTask=new Ext.util.DelayedTask(d.focus)}d.focusTask.delay(Ext.isNumber(c)?c:10,null,d,[e,false]);return d}if(d.rendered&&!d.isDestroyed&&d.isVisible(true)&&(a=d.getFocusEl())){if(a.isComponent){return a.focus(e,c)}if((g=a.dom)){if(a.needsTabIndex()){g.tabIndex=-1}if(d.floating){b=d.container.dom.scrollTop}a.focus();if(e===true){g.select()}}if(d.floating){d.toFront(true);if(b!==undefined){d.container.dom.scrollTop=b}}}return d},cancelFocus:function(){var a=this.focusTask;if(a){a.cancel()}},blur:function(){var a;if(this.rendered&&(a=this.getFocusEl())){a.blur()}return this},getEl:function(){return this.el},getResizeEl:function(){return this.el},getPositionEl:function(){return this.el},getActionEl:function(){return this.el},getVisibilityEl:function(){return this.el},onResize:Ext.emptyFn,getBubbleTarget:function(){return this.ownerCt||this.floatParent},getContentTarget:function(){return this.el},cloneConfig:function(c){c=c||{};var d=c.id||Ext.id(),a=Ext.applyIf(c,this.initialConfig),b;a.id=d;b=Ext.getClass(this);return new b(a)},getXType:function(){return this.self.xtype},findParentBy:function(a){var b;for(b=this.getBubbleTarget();b&&!a(b,this);b=b.getBubbleTarget()){}return b||null},findParentByType:function(a){return Ext.isFunction(a)?this.findParentBy(function(b){return b.constructor===a}):this.up(a)},bubble:function(c,b,a){var d=this;while(d){if(c.apply(b||d,a||[d])===false){break}d=d.getBubbleTarget()}return this},getProxy:function(){var a=this,b;if(!a.proxy){b=Ext.getBody();if(Ext.scopeResetCSS){a.proxyWrap=b=Ext.getBody().createChild({cls:Ext.resetCls})}a.proxy=a.el.createProxy(Ext.baseCSSPrefix+"proxy-el",b,true)}return a.proxy}});Ext.define("Ext.ElementLoader",{mixins:{observable:"Ext.util.Observable"},uses:["Ext.data.Connection","Ext.Ajax"],statics:{Renderer:{Html:function(a,b,c){a.getTarget().update(b.responseText,c.scripts===true);return true}}},url:null,params:null,baseParams:null,autoLoad:false,target:null,loadMask:false,ajaxOptions:null,scripts:false,isLoader:true,constructor:function(b){var c=this,a;b=b||{};Ext.apply(c,b);c.setTarget(c.target);c.addEvents("beforeload","exception","load");c.mixins.observable.constructor.call(c);if(c.autoLoad){a=c.autoLoad;if(a===true){a={}}c.load(a)}},setTarget:function(b){var a=this;b=Ext.get(b);if(a.target&&a.target!=b){a.abort()}a.target=b},getTarget:function(){return this.target||null},abort:function(){var a=this.active;if(a!==undefined){Ext.Ajax.abort(a.request);if(a.mask){this.removeMask()}delete this.active}},removeMask:function(){this.target.unmask()},addMask:function(a){this.target.mask(a===true?null:a)},load:function(i){i=Ext.apply({},i);var e=this,d=e.target,j=Ext.isDefined(i.loadMask)?i.loadMask:e.loadMask,b=Ext.apply({},i.params),a=Ext.apply({},i.ajaxOptions),g=i.callback||e.callback,h=i.scope||e.scope||e,c;Ext.applyIf(a,e.ajaxOptions);Ext.applyIf(i,a);Ext.applyIf(b,e.params);Ext.apply(b,e.baseParams);Ext.applyIf(i,{url:e.url});Ext.apply(i,{scope:e,params:b,callback:e.onComplete});if(e.fireEvent("beforeload",e,i)===false){return}if(j){e.addMask(j)}c=Ext.Ajax.request(i);e.active={request:c,options:i,mask:j,scope:h,callback:g,success:i.success||e.success,failure:i.failure||e.failure,renderer:i.renderer||e.renderer,scripts:Ext.isDefined(i.scripts)?i.scripts:e.scripts};e.setOptions(e.active,i)},setOptions:Ext.emptyFn,onComplete:function(b,h,a){var d=this,g=d.active,c=g.scope,e=d.getRenderer(g.renderer);if(h){h=e.call(d,d,a,g)!==false}if(h){Ext.callback(g.success,c,[d,a,b]);d.fireEvent("load",d,a,b)}else{Ext.callback(g.failure,c,[d,a,b]);d.fireEvent("exception",d,a,b)}Ext.callback(g.callback,c,[d,h,a,b]);if(g.mask){d.removeMask()}delete d.active},getRenderer:function(a){if(Ext.isFunction(a)){return a}return this.statics().Renderer.Html},startAutoRefresh:function(a,b){var c=this;c.stopAutoRefresh();c.autoRefresh=setInterval(function(){c.load(b)},a)},stopAutoRefresh:function(){clearInterval(this.autoRefresh);delete this.autoRefresh},isAutoRefreshing:function(){return Ext.isDefined(this.autoRefresh)},destroy:function(){var a=this;a.stopAutoRefresh();delete a.target;a.abort();a.clearListeners()}});Ext.define("Ext.ComponentLoader",{extend:"Ext.ElementLoader",statics:{Renderer:{Data:function(a,b,d){var g=true;try{a.getTarget().update(Ext.decode(b.responseText))}catch(c){g=false}return g},Component:function(a,c,h){var i=true,g=a.getTarget(),b=[];try{b=Ext.decode(c.responseText)}catch(d){i=false}if(i){g.suspendLayouts();if(h.removeAll){g.removeAll()}g.add(b);g.resumeLayouts(true)}return i}}},target:null,loadMask:false,renderer:"html",setTarget:function(b){var a=this;if(Ext.isString(b)){b=Ext.getCmp(b)}if(a.target&&a.target!=b){a.abort()}a.target=b},removeMask:function(){this.target.setLoading(false)},addMask:function(a){this.target.setLoading(a)},setOptions:function(b,a){b.removeAll=Ext.isDefined(a.removeAll)?a.removeAll:this.removeAll},getRenderer:function(b){if(Ext.isFunction(b)){return b}var a=this.statics().Renderer;switch(b){case"component":return a.Component;case"data":return a.Data;default:return Ext.ElementLoader.Renderer.Html}}});Ext.define("Ext.Template",{requires:["Ext.dom.Helper","Ext.util.Format"],inheritableStatics:{from:function(b,a){b=Ext.getDom(b);return new this(b.value||b.innerHTML,a||"")}},constructor:function(d){var g=this,b=arguments,a=[],c=0,e=b.length,h;g.initialConfig={};if(e===1&&Ext.isArray(d)){b=d;e=b.length}if(e>1){for(;c<e;c++){h=b[c];if(typeof h=="object"){Ext.apply(g.initialConfig,h);Ext.apply(g,h)}else{a.push(h)}}}else{a.push(d)}g.html=a.join("");if(g.compiled){g.compile()}},isTemplate:true,disableFormats:false,re:/\{([\w\-]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?\}/g,apply:function(a){var h=this,d=h.disableFormats!==true,g=Ext.util.Format,c=h,b;if(h.compiled){return h.compiled(a).join("")}function e(i,k,l,j){if(l&&d){if(j){j=[a[k]].concat(Ext.functionFactory("return ["+j+"];")())}else{j=[a[k]]}if(l.substr(0,5)=="this."){return c[l.substr(5)].apply(c,j)}else{return g[l].apply(g,j)}}else{return a[k]!==undefined?a[k]:""}}b=h.html.replace(h.re,e);return b},applyOut:function(a,b){var c=this;if(c.compiled){b.push.apply(b,c.compiled(a))}else{b.push(c.apply(a))}return b},applyTemplate:function(){return this.apply.apply(this,arguments)},set:function(a,c){var b=this;b.html=a;b.compiled=null;return c?b.compile():b},compileARe:/\\/g,compileBRe:/(\r\n|\n)/g,compileCRe:/'/g,compile:function(){var me=this,fm=Ext.util.Format,useFormat=me.disableFormats!==true,body,bodyReturn;function fn(m,name,format,args){if(format&&useFormat){args=args?","+args:"";if(format.substr(0,5)!="this."){format="fm."+format+"("}else{format="this."+format.substr(5)+"("}}else{args="";format="(values['"+name+"'] == undefined ? '' : "}return"',"+format+"values['"+name+"']"+args+") ,'"}bodyReturn=me.html.replace(me.compileARe,"\\\\").replace(me.compileBRe,"\\n").replace(me.compileCRe,"\\'").replace(me.re,fn);body="this.compiled = function(values){ return ['"+bodyReturn+"'];};";eval(body);return me},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(b,d,a,e){var c=Ext.DomHelper.insertHtml(b,Ext.getDom(d),this.apply(a));return e?Ext.get(c):c},overwrite:function(c,a,d){var b=Ext.DomHelper.overwrite(Ext.getDom(c),this.apply(a));return d?Ext.get(b):b}});Ext.define("Ext.XTemplateParser",{constructor:function(a){Ext.apply(this,a)},doTpl:Ext.emptyFn,parse:function(l){var v=this,p=l.length,o={elseif:"elif"},q=v.topRe,c=v.actionsRe,e,d,j,n,h,k,i,u,r,b,g,a;v.level=0;v.stack=d=[];for(e=0;e<p;e=b){q.lastIndex=e;n=q.exec(l);if(!n){v.doText(l.substring(e,p));break}r=n.index;b=q.lastIndex;if(e<r){v.doText(l.substring(e,r))}if(n[1]){b=l.indexOf("%}",r+2);v.doEval(l.substring(r+2,b));b+=2}else{if(n[2]){b=l.indexOf("]}",r+2);v.doExpr(l.substring(r+2,b));b+=2}else{if(n[3]){v.doTag(n[3])}else{if(n[4]){g=null;while((u=c.exec(n[4]))!==null){j=u[2]||u[3];if(j){j=Ext.String.htmlDecode(j);h=u[1];h=o[h]||h;g=g||{};k=g[h];if(typeof k=="string"){g[h]=[k,j]}else{if(k){g[h].push(j)}else{g[h]=j}}}}if(!g){if(v.elseRe.test(n[4])){v.doElse()}else{if(v.defaultRe.test(n[4])){v.doDefault()}else{v.doTpl();d.push({type:"tpl"})}}}else{if(g["if"]){v.doIf(g["if"],g);d.push({type:"if"})}else{if(g["switch"]){v.doSwitch(g["switch"],g);d.push({type:"switch"})}else{if(g["case"]){v.doCase(g["case"],g)}else{if(g.elif){v.doElseIf(g.elif,g)}else{if(g["for"]){++v.level;if(a=v.propRe.exec(n[4])){g.propName=a[1]||a[2]}v.doFor(g["for"],g);d.push({type:"for",actions:g})}else{if(g.exec){v.doExec(g.exec,g);d.push({type:"exec",actions:g})}}}}}}}}else{if(n[0].length===5){d.push({type:"tpl"})}else{i=d.pop();v.doEnd(i.type,i.actions);if(i.type=="for"){--v.level}}}}}}}},topRe:/(?:(\{\%)|(\{\[)|\{([^{}]*)\})|(?:<tpl([^>]*)\>)|(?:<\/tpl>)/g,actionsRe:/\s*(elif|elseif|if|for|exec|switch|case|eval)\s*\=\s*(?:(?:"([^"]*)")|(?:'([^']*)'))\s*/g,propRe:/prop=(?:(?:"([^"]*)")|(?:'([^']*)'))/,defaultRe:/^\s*default\s*$/,elseRe:/^\s*else\s*$/});Ext.define("Ext.XTemplateCompiler",{extend:"Ext.XTemplateParser",useEval:Ext.isGecko,useIndex:Ext.isIE6||Ext.isIE7,useFormat:true,propNameRe:/^[\w\d\$]*$/,compile:function(a){var c=this,b=c.generate(a);return c.useEval?c.evalTpl(b):(new Function("Ext",b))(Ext)},generate:function(a){var d=this,b="var fm=Ext.util.Format,ts=Object.prototype.toString;",c;d.maxLevel=0;d.body=["var c0=values, a0="+d.createArrayTest(0)+", p0=parent, n0=xcount, i0=xindex, v;\n"];if(d.definitions){if(typeof d.definitions==="string"){d.definitions=[d.definitions,b]}else{d.definitions.push(b)}}else{d.definitions=[b]}d.switches=[];d.parse(a);d.definitions.push((d.useEval?"$=":"return")+" function ("+d.fnArgs+") {",d.body.join(""),"}");c=d.definitions.join("\n");d.definitions.length=d.body.length=d.switches.length=0;delete d.definitions;delete d.body;delete d.switches;return c},doText:function(c){var b=this,a=b.body;c=c.replace(b.aposRe,"\\'").replace(b.newLineRe,"\\n");if(b.useIndex){a.push("out[out.length]='",c,"'\n")}else{a.push("out.push('",c,"')\n")}},doExpr:function(b){var a=this.body;a.push("if ((v="+b+")!==undefined) out");if(this.useIndex){a.push("[out.length]=v+''\n")}else{a.push(".push(v+'')\n")}},doTag:function(a){this.doExpr(this.parseTag(a))},doElse:function(){this.body.push("} else {\n")},doEval:function(a){this.body.push(a,"\n")},doIf:function(b,c){var a=this;if(b==="."){a.body.push("if (values) {\n")}else{if(a.propNameRe.test(b)){a.body.push("if (",a.parseTag(b),") {\n")}else{a.body.push("if (",a.addFn(b),a.callFn,") {\n")}}if(c.exec){a.doExec(c.exec)}},doElseIf:function(b,c){var a=this;if(b==="."){a.body.push("else if (values) {\n")}else{if(a.propNameRe.test(b)){a.body.push("} else if (",a.parseTag(b),") {\n")}else{a.body.push("} else if (",a.addFn(b),a.callFn,") {\n")}}if(c.exec){a.doExec(c.exec)}},doSwitch:function(b){var a=this;if(b==="."){a.body.push("switch (values) {\n")}else{if(a.propNameRe.test(b)){a.body.push("switch (",a.parseTag(b),") {\n")}else{a.body.push("switch (",a.addFn(b),a.callFn,") {\n")}}a.switches.push(0)},doCase:function(e){var d=this,c=Ext.isArray(e)?e:[e],g=d.switches.length-1,a,b;if(d.switches[g]){d.body.push("break;\n")}else{d.switches[g]++}for(b=0,g=c.length;b<g;++b){a=d.intRe.exec(c[b]);c[b]=a?a[1]:("'"+c[b].replace(d.aposRe,"\\'")+"'")}d.body.push("case ",c.join(": case "),":\n")},doDefault:function(){var a=this,b=a.switches.length-1;if(a.switches[b]){a.body.push("break;\n")}else{a.switches[b]++}a.body.push("default:\n")},doEnd:function(b,d){var c=this,a=c.level-1;if(b=="for"){if(d.exec){c.doExec(d.exec)}c.body.push("}\n");c.body.push("parent=p",a,";values=r",a+1,";xcount=n",a,";xindex=i",a,"\n")}else{if(b=="if"||b=="switch"){c.body.push("}\n")}}},doFor:function(g,i){var e=this,d,b=e.level,a=b-1,c="p"+b,h;if(g==="."){d="values"}else{if(e.propNameRe.test(g)){d=e.parseTag(g)}else{d=e.addFn(g)+e.callFn}}if(e.maxLevel<b){e.maxLevel=b;e.body.push("var ")}if(g=="."){h="c"+b}else{h="a"+a+"?c"+a+"[i"+a+"]:p"+b}e.body.push("i",b,"=0,n",b,"=0,c",b,"=",d,",a",b,"=",e.createArrayTest(b),",p",b,"=c",a,",r",b,"=values;\n","parent=",h,"\n","if (c",b,"){if(a",b,"){n",b,"=c",b,".length;}else if (c",b,".isMixedCollection){c",b,"=c",b,".items;n",b,"=c",b,".length;}else if(c",b,".isStore){c",b,"=c",b,".data.items;n",b,"=c",b,".length;}else{c",b,"=[c",b,"];n",b,"=1;}}\n","for (xcount=n",b,";i",b,"<n"+b+";++i",b,"){\n","values=c",b,"[i",b,"]");if(i.propName){e.body.push(".",i.propName)}e.body.push("\n","xindex=i",b,"+1\n")},createArrayTest:("isArray" in Array)?function(a){return"Array.isArray(c"+a+")"}:function(a){return"ts.call(c"+a+')==="[object Array]"'},doExec:function(c,d){var b=this,a="f"+b.definitions.length;b.definitions.push("function "+a+"("+b.fnArgs+") {"," try { with(values) {","  "+c," }} catch(e) {","}","}");b.body.push(a+b.callFn+"\n")},addFn:function(a){var c=this,b="f"+c.definitions.length;if(a==="."){c.definitions.push("function "+b+"("+c.fnArgs+") {"," return values","}")}else{if(a===".."){c.definitions.push("function "+b+"("+c.fnArgs+") {"," return parent","}")}else{c.definitions.push("function "+b+"("+c.fnArgs+") {"," try { with(values) {","  return("+a+")"," }} catch(e) {","}","}")}}return b},parseTag:function(b){var h=this,a=h.tagRe.exec(b),e=a[1],i=a[2],d=a[3],g=a[4],c;if(e=="."){if(!h.validTypes){h.definitions.push("var validTypes={string:1,number:1,boolean:1};");h.validTypes=true}c='validTypes[typeof values] || ts.call(values) === "[object Date]" ? values : ""'}else{if(e=="#"){c="xindex"}else{if(e.substr(0,7)=="parent."){c=e}else{if(isNaN(e)&&e.indexOf("-")==-1&&e.indexOf(".")!=-1){c="values."+e}else{c="values['"+e+"']"}}}}if(g){c="("+c+g+")"}if(i&&h.useFormat){d=d?","+d:"";if(i.substr(0,5)!="this."){i="fm."+i+"("}else{i+="("}}else{return c}return i+c+d+")"},evalTpl:function($){eval($);return $},newLineRe:/\r\n|\r|\n/g,aposRe:/[']/g,intRe:/^\s*(\d+)\s*$/,tagRe:/([\w-\.\#]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?(\s?[\+\-\*\/]\s?[\d\.\+\-\*\/\(\)]+)?/},function(){var a=this.prototype;a.fnArgs="out,values,parent,xindex,xcount";a.callFn=".call(this,"+a.fnArgs+")"});Ext.define("Ext.XTemplate",{extend:"Ext.Template",requires:"Ext.XTemplateCompiler",emptyObj:{},apply:function(a,b){return this.applyOut(a,[],b).join("")},applyOut:function(a,b,d){var g=this,c;if(!g.fn){c=new Ext.XTemplateCompiler({useFormat:g.disableFormats!==true,definitions:g.definitions});g.fn=c.compile(g.html)}try{g.fn.call(g,b,a,d||g.emptyObj,1,1)}catch(h){}return b},compile:function(){return this},statics:{getTpl:function(a,c){var b=a[c],d;if(b&&!b.isTemplate){b=Ext.ClassManager.dynInstantiate("Ext.XTemplate",b);if(a.hasOwnProperty(c)){a[c]=b}else{for(d=a.self.prototype;d;d=d.superclass){if(d.hasOwnProperty(c)){d[c]=b;break}}}}return b||null}}});Ext.define("Ext.layout.Layout",{requires:["Ext.XTemplate"],uses:["Ext.layout.Context"],isLayout:true,initialized:false,running:false,autoSizePolicy:{setsWidth:0,setsHeight:0},statics:{layoutsByType:{},create:function(g,e){var k=Ext.ClassManager,c=this.layoutsByType,d,h,b,a,i,j;if(!g||typeof g==="string"){i=g||e;b={}}else{if(g.isLayout){return g}else{b=g;i=g.type||e}}if(!(a=c[i])){d="layout."+i;h=k.getNameByAlias(d);if(!h){j=true}a=k.get(h);if(j||!a){return k.instantiateByAlias(d,b||{})}c[i]=a}return new a(b)}},constructor:function(a){var b=this;b.id=Ext.id(null,b.type+"-");Ext.apply(b,a);b.layoutCount=0},beginLayout:Ext.emptyFn,beginLayoutCycle:function(c){var b=this,a=b.context,d;if(b.lastWidthModel!=c.widthModel){if(b.lastWidthModel){d=true}b.lastWidthModel=c.widthModel}if(b.lastHeightModel!=c.heightModel){if(b.lastWidthModel){d=true}b.lastHeightModel=c.heightModel}if(d){(a=c.context).clearTriggers(b,false);a.clearTriggers(b,true);b.triggerCount=0}},finishedLayout:function(){this.ownerContext=null},redoLayout:Ext.emptyFn,undoLayout:Ext.emptyFn,getAnimatePolicy:function(){return this.animatePolicy},getItemSizePolicy:function(a){return this.autoSizePolicy},isItemBoxParent:function(a){return false},isItemLayoutRoot:function(d){var c=d.getSizeModel(),b=c.width,a=c.height;if(!d.componentLayout.lastComponentSize&&(b.calculated||a.calculated)){return false}return !b.shrinkWrap&&!a.shrinkWrap},isItemShrinkWrap:function(a){return a.shrinkWrap},isRunning:function(){return !!this.ownerContext},getItemsRenderTree:function(d,b){var h=d.length,e,g,c,a;if(h){a=[];for(e=0;e<h;++e){g=d[e];if(!g.rendered){if(b&&(b[g.id]!==undefined)){c=b[g.id]}else{this.configureItem(g);c=g.getRenderTree();if(b){b[g.id]=c}}if(c){a.push(c)}}}}return a},finishRender:Ext.emptyFn,finishRenderItems:function(e,a){var d=a.length,b,c;for(b=0;b<d;b++){c=a[b];if(c.rendering){c.finishRender(b);this.afterRenderItem(c)}}},renderChildren:function(){var b=this,a=b.getLayoutItems(),c=b.getRenderTarget();b.renderItems(a,c)},renderItems:function(a,g){var e=this,d=a.length,b=0,c;if(d){Ext.suspendLayouts();for(;b<d;b++){c=a[b];if(c&&!c.rendered){e.renderItem(c,g,b)}else{if(!e.isValidParent(c,g,b)){e.moveItem(c,g,b)}else{e.configureItem(c)}}}Ext.resumeLayouts(true)}},isValidParent:function(d,e,a){var b=d.el?d.el.dom:Ext.getDom(d),c=(e&&e.dom)||e;if(b.parentNode&&b.parentNode.className.indexOf(Ext.baseCSSPrefix+"resizable-wrap")!==-1){b=b.parentNode}if(b&&c){if(typeof a=="number"){return b===c.childNodes[a]}return b.parentNode===c}return false},configureItem:function(a){a.ownerLayout=this},renderItem:function(c,d,a){var b=this;if(!c.rendered){b.configureItem(c);c.render(d,a);b.afterRenderItem(c)}},moveItem:function(b,c,a){c=c.dom||c;if(typeof a=="number"){a=c.childNodes[a]}c.insertBefore(b.el.dom,a||null);b.container=Ext.get(c);this.configureItem(b)},onContentChange:function(){this.owner.updateLayout();return true},initLayout:function(){this.initialized=true},setOwner:function(a){this.owner=a},getLayoutItems:function(){return[]},afterRenderItem:Ext.emptyFn,onAdd:Ext.emptyFn,onRemove:Ext.emptyFn,onDestroy:Ext.emptyFn,afterRemove:function(e){var d=this,c=e.el,b=d.owner,a;if(e.rendered){a=[].concat(d.itemCls||[]);if(b.itemCls){a=Ext.Array.push(a,b.itemCls)}if(a.length){c.removeCls(a)}}delete e.ownerLayout},destroy:function(){var a=this,b;if(a.targetCls){b=a.getTarget();if(b){b.removeCls(a.targetCls)}}a.onDestroy()},sortWeightedItems:function(a,d){for(var b=0,c=a.length;b<c;++b){a[b].$i=b}Ext.Array.sort(a,function(g,e){var h=e.weight-g.weight;if(!h){h=g.$i-e.$i;if(g[d]){h=-h}}return h});for(b=0;b<c;++b){delete a[b].$i}}},function(){var l=this,k={},m=[],g,e,b,a,d;l.prototype.sizeModels=l.sizeModels=k;var h=function(j){var n=this,i=j.name;Ext.apply(Ext.apply(n,c),j);n[i]=true;h[i]=k[i]=n;n.fixed=!(n.auto=n.natural||n.shrinkWrap);n.ordinal=m.length;m.push(n)};Ext.layout.SizeModel=h;var c={calculated:false,configured:false,constrainedMax:false,constrainedMin:false,natural:false,shrinkWrap:false,calculatedFromConfigured:false,calculatedFromNatural:false,calculatedFromShrinkWrap:false,names:null};new h({name:"calculated"});new h({name:"configured",names:{width:"width",height:"height"}});new h({name:"natural"});new h({name:"shrinkWrap"});new h({name:"calculatedFromConfigured",configured:true,names:{width:"width",height:"height"}});new h({name:"calculatedFromNatural",natural:true});new h({name:"calculatedFromShrinkWrap",shrinkWrap:true});new h({name:"constrainedMax",configured:true,constrained:true,names:{width:"maxWidth",height:"maxHeight"}});new h({name:"constrainedMin",configured:true,constrained:true,names:{width:"minWidth",height:"minHeight"}});for(g=0,b=m.length;g<b;++g){d=m[g];d.pairsByHeightOrdinal=a=[];for(e=0;e<b;++e){a.push({width:d,height:m[e]})}}});Ext.define("Ext.layout.container.Container",{extend:"Ext.layout.Layout",alternateClassName:"Ext.layout.ContainerLayout",mixins:{elementCt:"Ext.util.ElementContainer"},requires:["Ext.XTemplate"],type:"container",manageOverflow:0,beginCollapse:Ext.emptyFn,beginExpand:Ext.emptyFn,animatePolicy:null,childEls:["overflowPadderEl"],renderTpl:["{%this.renderBody(out,values)%}"],usesContainerHeight:true,usesContainerWidth:true,usesHeight:true,usesWidth:true,reserveScrollbar:false,lastOverflowAdjust:{width:0,height:0},constructor:function(){this.callParent(arguments);this.mixins.elementCt.constructor.call(this)},destroy:function(){this.callParent();this.mixins.elementCt.destroy.call(this)},initLayout:function(){var b=this,a=Ext.getScrollbarSize().width;b.callParent();if(a&&b.manageOverflow&&!b.hasOwnProperty("lastOverflowAdjust")){if(b.owner.autoScroll||b.reserveScrollbar){b.lastOverflowAdjust={width:a,height:0}}}},beginLayout:function(a){this.callParent(arguments);a.targetContext=a.getEl("getTarget",this);this.cacheChildItems(a)},beginLayoutCycle:function(c,a){var b=this,d=b.overflowPadderEl;b.callParent(arguments);if(!c.state.overflowAdjust){c.state.overflowAdjust=b.lastOverflowAdjust}if(a){if(b.usesContainerHeight){++c.consumersContainerHeight}if(b.usesContainerWidth){++c.consumersContainerWidth}}if(d){d.setStyle("display","none")}},completeLayout:function(a){this.lastOverflowAdjust=a.state.overflowAdjust},cacheChildItems:function(e){var c=e.context,g=[],a=this.getVisibleItems(),d=a.length,b;e.childItems=g;e.visibleItems=a;for(b=0;b<d;++b){g.push(c.getCmp(a[b]))}},cacheElements:function(){var a=this.owner;this.applyChildEls(a.el,a.id)},calculateContentSize:function(q,m){var B=this,d=(m||0)|B.manageOverflow|((q.widthModel.shrinkWrap?1:0)|(q.heightModel.shrinkWrap?2:0)),c=(d&1)||undefined,j=(d&2)||undefined,b=q.childItems,g=b.length,w=0,u=0,n=0,e=q.props,r,p,o,A,h,l,t,z,y,s,x,a,v,k;if(c){if(isNaN(e.contentWidth)){++n}else{c=undefined}}if(j){if(isNaN(e.contentHeight)){++n}else{j=undefined}}if(n){for(x=0;x<g;++x){t=b[x];l=t.target;s=j&&t.getProp("height");v=c&&t.getProp("width");a=t.getMarginInfo();if((c&&isNaN(l.x))||(j&&isNaN(l.y))){k=l.el.getXY();if(!r){r=q.targetContext.el.getXY();h=q.targetContext.getBorderInfo();p=r[0]+h.left;o=r[1]+h.top}z=k[0]-p;y=k[1]-o}else{z=l.x;y=l.y}s+=a.bottom;v+=a.right;w=Math.max(w,y+s);u=Math.max(u,z+v);if(isNaN(w)&&isNaN(u)){B.done=false;return}}if(c||j){A=q.targetContext.getPaddingInfo()}if(c&&!q.setContentWidth(u+A.right)){B.done=false}if(j&&!q.setContentHeight(w+A.bottom)){B.done=false}}},calculateOverflow:function(n,s,h){var w=this,a=w.owner,l=w.manageOverflow,d=n.state,m=d.overflowAdjust,g,k,c,o,b,q,t,j,r,e,p,u,i,v;if(l&&!d.secondPass&&!w.reserveScrollbar){if(a.autoScroll){i=v=true}else{if(a.overflowX){i=a.overflowX=="auto"}else{q=n.targetContext.getStyle("overflow-x");i=q&&q!="hidden"&&q!="scroll"}if(a.overflowY){v=a.overflowY=="auto"}else{q=n.targetContext.getStyle("overflow-y");v=q&&q!="hidden"&&q!="scroll"}}if(!s.gotWidth){i=false}if(!s.gotHeight){v=false}if(i||v){t=Ext.getScrollbarSize();j=n.peek("contentWidth");r=n.peek("contentHeight");e=s.width;p=s.height;u=w.getScrollbarsNeeded(e,p,j,r);d.overflowState=u;if(typeof h=="number"){u&=~h}m={width:(i&&(u&2))?t.width:0,height:(v&&(u&1))?t.height:0};if(m.width!==w.lastOverflowAdjust.width||m.height!==w.lastOverflowAdjust.height){w.done=false;n.invalidate({state:{overflowAdjust:m,overflowState:d.overflowState,secondPass:true}})}}}if(!w.done){return}c=n.padElContext||(n.padElContext=n.getEl("overflowPadderEl",w));if(c){u=d.overflowState;g=s.width;k=0;if(u){o=n.targetContext.getPaddingInfo();b=w.scrollRangeFlags;if((u&2)&&(b&1)){k+=o.bottom}if((u&1)&&(b&4)){g+=o.right}c.setProp("display","");c.setSize(g,k)}else{c.setProp("display","none")}}},configureItem:function(c){var b=this,a=b.owner.itemCls,d=[].concat(b.itemCls||[]);b.callParent(arguments);if(a){d=Ext.Array.push(d,a)}c.addCls(d)},doRenderBody:function(a,b){this.renderItems(a,b);this.renderContent(a,b)},doRenderContainer:function(b,e){var c=e.$comp.layout,a=c.getRenderTpl(),d=c.getRenderData();a.applyOut(d,b)},doRenderItems:function(b,d){var c=d.$layout,a=c.getRenderTree();if(a){Ext.DomHelper.generateMarkup(a,b)}},doRenderPadder:function(b,d){var c=d.$layout,a=c.owner,e=c.getScrollRangeFlags();if(c.manageOverflow==2){if(e&5){b.push('<div id="',a.id,'-overflowPadderEl" ','style="font-size: 1px; width:1px; height: 1px;');b.push('"></div>');c.scrollRangeFlags=e}}},finishRender:function(){var b=this,c,a;b.callParent();b.cacheElements();c=b.getRenderTarget();a=b.getLayoutItems();if(b.targetCls){b.getTarget().addCls(b.targetCls)}b.finishRenderItems(c,a)},notifyOwner:function(){this.owner.afterLayout(this)},getContainerSize:function(c,h){var d=c.targetContext,g=d.getFrameInfo(),k=d.getPaddingInfo(),j=0,l=0,a=c.state.overflowAdjust,e,i,b,m;if(!c.widthModel.shrinkWrap){++l;b=h?d.getDomProp("width"):d.getProp("width");e=(typeof b=="number");if(e){++j;b-=g.width+k.width;if(a){b-=a.width}}}if(!c.heightModel.shrinkWrap){++l;m=h?d.getDomProp("height"):d.getProp("height");i=(typeof m=="number");if(i){++j;m-=g.height+k.height;if(a){m-=a.height}}}return{width:b,height:m,needed:l,got:j,gotAll:j==l,gotWidth:e,gotHeight:i}},getLayoutItems:function(){var a=this.owner,b=a&&a.items;return(b&&b.items)||[]},getRenderData:function(){var a=this.owner;return{$comp:a,$layout:this,ownerId:a.id}},getRenderedItems:function(){var e=this,h=e.getRenderTarget(),a=e.getLayoutItems(),d=a.length,g=[],b,c;for(b=0;b<d;b++){c=a[b];if(c.rendered&&e.isValidParent(c,h,b)){g.push(c)}}return g},getRenderTarget:function(){return this.owner.getTargetEl()},getElementTarget:function(){return this.getRenderTarget()},getRenderTpl:function(){var a=this,b=Ext.XTemplate.getTpl(this,"renderTpl");if(!b.renderContent){a.owner.setupRenderTpl(b)}return b},getRenderTree:function(){var a,c=this.owner.items,d,b={};do{d=c.generation;a=this.getItemsRenderTree(this.getLayoutItems(),b)}while(c.generation!==d);return a},getScrollbarsNeeded:function(c,i,b,h){var a=Ext.getScrollbarSize(),e=typeof c=="number",j=typeof i=="number",g=0,d=0;if(!a.width){return 0}if(j&&i<h){d=2;c-=a.width}if(e&&c<b){g=1;if(!d&&j){i-=a.height;if(i<h){d=2}}}return d+g},getScrollRangeFlags:(function(){var a=-1;return function(){if(a<0){var g=Ext.getBody().createChild({cls:Ext.baseCSSPrefix+"border-box",style:{width:"100px",height:"100px",padding:"10px",overflow:"auto"},children:[{style:{border:"1px solid red",width:"150px",height:"150px",margin:"0 5px 5px 0"}}]}),d=g.dom.scrollHeight,c=g.dom.scrollWidth,e={175:0,165:1,170:2,160:3},b={175:0,165:4,170:8,160:12};a=(e[d]||0)|(b[c]||0);g.remove()}return a}}()),getTarget:function(){return this.owner.getTargetEl()},getVisibleItems:function(){var g=this.getRenderTarget(),b=this.getLayoutItems(),e=b.length,a=[],c,d;for(c=0;c<e;c++){d=b[c];if(d.rendered&&this.isValidParent(d,g,c)&&d.hidden!==true){a.push(d)}}return a},setupRenderTpl:function(b){var a=this;b.renderBody=a.doRenderBody;b.renderContainer=a.doRenderContainer;b.renderItems=a.doRenderItems;b.renderPadder=a.doRenderPadder}});Ext.define("Ext.layout.container.Editor",{alias:"layout.editor",extend:"Ext.layout.container.Container",autoSizeDefault:{width:"field",height:"field"},getItemSizePolicy:function(c){var b=this,a=b.owner.autoSize;return b.sizePolicy||(b.sizePolicy={setsWidth:a&&a.width==="boundEl"?1:0,setsHeight:a&&a.height==="boundEl"?1:0})},calculate:function(g){var e=this,b=e.owner,a=b.autoSize,d,c;if(a===true){a=e.autoSizeDefault}if(a){d=e.getDimension(b,a.width,"getWidth",b.width);c=e.getDimension(b,a.height,"getHeight",b.height)}g.childItems[0].setSize(d,c);g.setWidth(d);g.setHeight(c);g.setContentSize(d||b.field.getWidth(),c||b.field.getHeight())},getDimension:function(a,b,d,c){switch(b){case"boundEl":return a.boundEl[d]();case"field":return undefined;default:return c}}});Ext.define("Ext.layout.component.Component",{extend:"Ext.layout.Layout",type:"component",isComponentLayout:true,nullBox:{},usesContentHeight:true,usesContentWidth:true,usesHeight:true,usesWidth:true,beginLayoutCycle:function(c,p){var k=this,b=k.owner,e=c.ownerCtContext,g=c.heightModel,h=c.widthModel,i=b.el.dom===document.body,d=b.lastBox||k.nullBox,n=b.el.lastBox||k.nullBox,a=!i,m,o,l,j;k.callParent(arguments);if(p){if(k.usesContentWidth){++c.consumersContentWidth}if(k.usesContentHeight){++c.consumersContentHeight}if(k.usesWidth){++c.consumersWidth}if(k.usesHeight){++c.consumersHeight}if(e&&!e.hasRawContent){m=b.ownerLayout;if(m.usesWidth){++c.consumersWidth}if(m.usesHeight){++c.consumersHeight}}}if(h.configured){l=h.names.width;if(!i){a=p?b[l]!==n.width:h.constrained}c.setWidth(b[l],a)}else{if(c.isTopLevel){if(h.calculated){o=d.width;c.setWidth(o,o!=n.width)}o=d.x;c.setProp("x",o,o!=n.x)}}if(g.configured){j=g.names.height;if(!i){a=p?b[j]!==n.height:g.constrained}c.setHeight(b[j],a)}else{if(c.isTopLevel){if(g.calculated){o=d.height;c.setHeight(o,o!=n.height)}o=d.y;c.setProp("y",o,o!=n.y)}}},finishedLayout:function(b){var h=this,l=b.children,a=h.owner,e,c,k,d,g,j;if(l){e=l.length;for(c=0;c<e;c++){k=l[c];k.el.lastBox=k.props}}b.previousSize=h.lastComponentSize;h.lastComponentSize=a.el.lastBox=g=b.props;a.lastBox=d={};j=g.x;if(j!==undefined){d.x=j}j=g.y;if(j!==undefined){d.y=j}j=g.width;if(j!==undefined){d.width=j}j=g.height;if(j!==undefined){d.height=j}h.callParent(arguments)},notifyOwner:function(d){var c=this,a=c.lastComponentSize,e=d.previousSize,b=[a.width,a.height];if(e){b.push(e.width,e.height)}c.owner.afterComponentLayout.apply(c.owner,b)},getTarget:function(){return this.owner.el},getRenderTarget:function(){return this.owner.el},cacheTargetInfo:function(b){var a=this,d=a.targetInfo,c;if(!d){c=b.getEl("getTarget",a);a.targetInfo=d={padding:c.getPaddingInfo(),border:c.getBorderInfo()}}return d},measureAutoDimensions:function(m,i){var t=this,a=t.owner,q=a.layout,d=m.heightModel,h=m.widthModel,c=m.boxParent,n=m.isBoxParent,b=m.props,j,u={gotWidth:false,gotHeight:false,isContainer:(j=!m.hasRawContent)},s=i||3,p,e,k=0,g=0,l,o,r;if(h.shrinkWrap&&m.consumersContentWidth){++k;p=!(s&1);if(j){if(p){u.contentWidth=0;u.gotWidth=true;++g}else{if((u.contentWidth=m.getProp("contentWidth"))!==undefined){u.gotWidth=true;++g}}}else{o=b.contentWidth;if(typeof o=="number"){u.contentWidth=o;u.gotWidth=true;++g}else{if(p){l=true}else{if(!m.hasDomProp("containerChildrenDone")){l=false}else{if(n||!c||c.widthModel.shrinkWrap){l=true}else{l=c.hasDomProp("width")}}}if(l){if(p){r=0}else{if(q&&q.measureContentWidth){r=q.measureContentWidth(m)}else{r=t.measureContentWidth(m)}}if(!isNaN(u.contentWidth=r)){m.setContentWidth(r,true);u.gotWidth=true;++g}}}}}else{if(h.natural&&m.consumersWidth){++k;o=b.width;if(typeof o=="number"){u.width=o;u.gotWidth=true;++g}else{if(n||!c){l=true}else{l=c.hasDomProp("width")}if(l){if(!isNaN(u.width=t.measureOwnerWidth(m))){m.setWidth(u.width,false);u.gotWidth=true;++g}}}}}if(d.shrinkWrap&&m.consumersContentHeight){++k;e=!(s&2);if(j){if(e){u.contentHeight=0;u.gotHeight=true;++g}else{if((u.contentHeight=m.getProp("contentHeight"))!==undefined){u.gotHeight=true;++g}}}else{o=b.contentHeight;if(typeof o=="number"){u.contentHeight=o;u.gotHeight=true;++g}else{if(e){l=true}else{if(!m.hasDomProp("containerChildrenDone")){l=false}else{if(a.noWrap){l=true}else{if(!h.shrinkWrap){l=(m.bodyContext||m).hasDomProp("width")}else{if(n||!c||c.widthModel.shrinkWrap){l=true}else{l=c.hasDomProp("width")}}}}}if(l){if(e){r=0}else{if(q&&q.measureContentHeight){r=q.measureContentHeight(m)}else{r=t.measureContentHeight(m)}}if(!isNaN(u.contentHeight=r)){m.setContentHeight(r,true);u.gotHeight=true;++g}}}}}else{if(d.natural&&m.consumersHeight){++k;o=b.height;if(typeof o=="number"){u.height=o;u.gotHeight=true;++g}else{if(n||!c){l=true}else{l=c.hasDomProp("width")}if(l){if(!isNaN(u.height=t.measureOwnerHeight(m))){m.setHeight(u.height,false);u.gotHeight=true;++g}}}}}if(c){m.onBoxMeasured()}u.gotAll=g==k;return u},measureContentWidth:function(a){return a.el.getWidth()-a.getFrameInfo().width},measureContentHeight:function(a){return a.el.getHeight()-a.getFrameInfo().height},measureOwnerHeight:function(a){return a.el.getHeight()},measureOwnerWidth:function(a){return a.el.getWidth()}});Ext.define("Ext.layout.component.Auto",{alias:"layout.autocomponent",extend:"Ext.layout.component.Component",type:"autocomponent",setHeightInDom:false,setWidthInDom:false,waitForOuterHeightInDom:false,waitForOuterWidthInDom:false,beginLayoutCycle:function(d,b){var c=this,g=c.lastWidthModel,e=c.lastHeightModel,a=c.owner;c.callParent(arguments);if(g&&g.fixed&&d.widthModel.shrinkWrap){a.el.setWidth(null)}if(e&&e.fixed&&d.heightModel.shrinkWrap){a.el.setHeight(null)}},calculate:function(h){var g=this,e=g.measureAutoDimensions(h),b=h.heightModel,c=h.widthModel,d,a;if(e.gotWidth){if(c.shrinkWrap){g.publishOwnerWidth(h,e.contentWidth)}else{if(g.publishInnerWidth){g.publishInnerWidth(h,e.width)}}}else{if(!c.auto&&g.publishInnerWidth){d=g.waitForOuterWidthInDom?h.getDomProp("width"):h.getProp("width");if(d===undefined){g.done=false}else{g.publishInnerWidth(h,d)}}}if(e.gotHeight){if(b.shrinkWrap){g.publishOwnerHeight(h,e.contentHeight)}else{if(g.publishInnerHeight){g.publishInnerHeight(h,e.height)}}}else{if(!b.auto&&g.publishInnerHeight){a=g.waitForOuterHeightInDom?h.getDomProp("height"):h.getProp("height");if(a===undefined){g.done=false}else{g.publishInnerHeight(h,a)}}}if(!e.gotAll){g.done=false}},calculateOwnerHeightFromContentHeight:function(b,a){return a+b.getFrameInfo().height},calculateOwnerWidthFromContentWidth:function(b,a){return a+b.getFrameInfo().width},publishOwnerHeight:function(i,g){var e=this,b=e.owner,a=e.calculateOwnerHeightFromContentHeight(i,g),h,d,c;if(isNaN(a)){e.done=false}else{h=Ext.Number.constrain(a,b.minHeight,b.maxHeight);if(h==a){d=e.setHeightInDom}else{c=e.sizeModels[(h<a)?"constrainedMax":"constrainedMin"];a=h;if(i.heightModel.calculatedFromShrinkWrap){i.heightModel=c}else{i.invalidate({heightModel:c})}}i.setHeight(a,d)}},publishOwnerWidth:function(h,b){var g=this,a=g.owner,e=g.calculateOwnerWidthFromContentWidth(h,b),i,d,c;if(isNaN(e)){g.done=false}else{i=Ext.Number.constrain(e,a.minWidth,a.maxWidth);if(i==e){d=g.setWidthInDom}else{c=g.sizeModels[(i<e)?"constrainedMax":"constrainedMin"];e=i;if(h.widthModel.calculatedFromShrinkWrap){h.widthModel=c}else{h.invalidate({widthModel:c})}}h.setWidth(e,d)}}});Ext.define("Ext.layout.container.Auto",{alias:["layout.auto","layout.autocontainer"],extend:"Ext.layout.container.Container",type:"autocontainer",childEls:["clearEl"],renderTpl:["{%this.renderBody(out,values)%}",'<div id="{ownerId}-clearEl" class="',Ext.baseCSSPrefix,'clear" role="presentation"></div>'],calculate:function(b){var a=this,c;if(!b.hasDomProp("containerChildrenDone")){a.done=false}else{c=a.getContainerSize(b);if(!c.gotAll){a.done=false}a.calculateContentSize(b)}}});Ext.define("Ext.util.Filter",{anyMatch:false,exactMatch:false,caseSensitive:false,constructor:function(a){var b=this;Ext.apply(b,a);b.filter=b.filter||b.filterFn;if(b.filter===undefined){if(b.property===undefined||b.value===undefined){}else{b.filter=b.createFilterFn()}b.filterFn=b.filter}},createFilterFn:function(){var a=this,c=a.createValueMatcher(),b=a.property;return function(d){var e=a.getRoot.call(a,d)[b];return c===null?e===null:c.test(e)}},getRoot:function(b){var a=this.root;return a===undefined?b:b[a]},createValueMatcher:function(){var d=this,e=d.value,g=d.anyMatch,c=d.exactMatch,a=d.caseSensitive,b=Ext.String.escapeRegex;if(e===null){return e}if(!e.exec){e=String(e);if(g===true){e=b(e)}else{e="^"+b(e);if(c===true){e+="$"}}e=new RegExp(e,a?"":"i")}return e}});Ext.define("Ext.util.AbstractMixedCollection",{requires:["Ext.util.Filter"],mixins:{observable:"Ext.util.Observable"},isMixedCollection:true,generation:0,constructor:function(b,a){var c=this;c.items=[];c.map={};c.keys=[];c.length=0;c.allowFunctions=b===true;if(a){c.getKey=a}c.mixins.observable.constructor.call(c)},allowFunctions:false,add:function(b,e){var d=this,g=e,c=b,a;if(arguments.length==1){g=c;c=d.getKey(g)}if(typeof c!="undefined"&&c!==null){a=d.map[c];if(typeof a!="undefined"){return d.replace(c,g)}d.map[c]=g}d.generation++;d.length++;d.items.push(g);d.keys.push(c);if(d.hasListeners.add){d.fireEvent("add",d.length-1,g,c)}return g},getKey:function(a){return a.id},replace:function(c,e){var d=this,a,b;if(arguments.length==1){e=arguments[0];c=d.getKey(e)}a=d.map[c];if(typeof c=="undefined"||c===null||typeof a=="undefined"){return d.add(c,e)}d.generation++;b=d.indexOfKey(c);d.items[b]=e;d.map[c]=e;if(d.hasListeners.replace){d.fireEvent("replace",c,a,e)}return e},addAll:function(g){var e=this,d=0,b,a,c;if(arguments.length>1||Ext.isArray(g)){b=arguments.length>1?arguments:g;for(a=b.length;d<a;d++){e.add(b[d])}}else{for(c in g){if(g.hasOwnProperty(c)){if(e.allowFunctions||typeof g[c]!="function"){e.add(c,g[c])}}}}},each:function(e,d){var b=[].concat(this.items),c=0,a=b.length,g;for(;c<a;c++){g=b[c];if(e.call(d||g,g,c,a)===false){break}}},eachKey:function(e,d){var g=this.keys,b=this.items,c=0,a=g.length;for(;c<a;c++){e.call(d||window,g[c],b[c],c,a)}},findBy:function(e,d){var g=this.keys,b=this.items,c=0,a=b.length;for(;c<a;c++){if(e.call(d||window,b[c],g[c])){return b[c]}}return null},find:function(){if(Ext.isDefined(Ext.global.console)){Ext.global.console.warn("Ext.util.MixedCollection: find has been deprecated. Use findBy instead.")}return this.findBy.apply(this,arguments)},insert:function(a,b,e){var d=this,c=b,g=e;if(arguments.length==2){g=c;c=d.getKey(g)}if(d.containsKey(c)){d.suspendEvents();d.removeAtKey(c);d.resumeEvents()}if(a>=d.length){return d.add(c,g)}d.generation++;d.length++;Ext.Array.splice(d.items,a,0,g);if(typeof c!="undefined"&&c!==null){d.map[c]=g}Ext.Array.splice(d.keys,a,0,c);if(d.hasListeners.add){d.fireEvent("add",a,g,c)}return g},remove:function(a){this.generation++;return this.removeAt(this.indexOf(a))},removeAll:function(b){b=[].concat(b);var c,a=b.length;for(c=0;c<a;c++){this.remove(b[c])}return this},removeAt:function(a){var c=this,d,b;if(a<c.length&&a>=0){c.length--;d=c.items[a];Ext.Array.erase(c.items,a,1);b=c.keys[a];if(typeof b!="undefined"){delete c.map[b]}Ext.Array.erase(c.keys,a,1);if(c.hasListeners.remove){c.fireEvent("remove",d,b)}c.generation++;return d}return false},removeAtKey:function(a){return this.removeAt(this.indexOfKey(a))},getCount:function(){return this.length},indexOf:function(a){return Ext.Array.indexOf(this.items,a)},indexOfKey:function(a){return Ext.Array.indexOf(this.keys,a)},get:function(b){var d=this,a=d.map[b],c=a!==undefined?a:(typeof b=="number")?d.items[b]:undefined;return typeof c!="function"||d.allowFunctions?c:null},getAt:function(a){return this.items[a]},getByKey:function(a){return this.map[a]},contains:function(a){return typeof this.map[this.getKey(a)]!="undefined"},containsKey:function(a){return typeof this.map[a]!="undefined"},clear:function(){var a=this;a.length=0;a.items=[];a.keys=[];a.map={};a.generation++;if(a.hasListeners.clear){a.fireEvent("clear")}},first:function(){return this.items[0]},last:function(){return this.items[this.length-1]},sum:function(h,b,j,a){var c=this.extractValues(h,b),g=c.length,e=0,d;j=j||0;a=(a||a===0)?a:g-1;for(d=j;d<=a;d++){e+=c[d]}return e},collect:function(k,e,h){var l=this.extractValues(k,e),a=l.length,b={},c=[],j,g,d;for(d=0;d<a;d++){j=l[d];g=String(j);if((h||!Ext.isEmpty(j))&&!b[g]){b[g]=true;c.push(j)}}return c},extractValues:function(c,a){var b=this.items;if(a){b=Ext.Array.pluck(b,a)}return Ext.Array.pluck(b,c)},getRange:function(g,a){var e=this,c=e.items,b=[],d;if(c.length<1){return b}g=g||0;a=Math.min(typeof a=="undefined"?e.length-1:a,e.length-1);if(g<=a){for(d=g;d<=a;d++){b[b.length]=c[d]}}else{for(d=g;d>=a;d--){b[b.length]=c[d]}}return b},filter:function(d,c,g,a){var b=[],e;if(Ext.isString(d)){b.push(new Ext.util.Filter({property:d,value:c,anyMatch:g,caseSensitive:a}))}else{if(Ext.isArray(d)||d instanceof Ext.util.Filter){b=b.concat(d)}}e=function(h){var n=true,o=b.length,j,m,l,k;for(j=0;j<o;j++){m=b[j];l=m.filterFn;k=m.scope;n=n&&l.call(k,h)}return n};return this.filterBy(e)},filterBy:function(e,d){var j=this,a=new this.self(),h=j.keys,b=j.items,g=b.length,c;a.getKey=j.getKey;for(c=0;c<g;c++){if(e.call(d||j,b[c],h[c])){a.add(h[c],b[c])}}return a},findIndex:function(c,b,e,d,a){if(Ext.isEmpty(b,false)){return -1}b=this.createValueMatcher(b,d,a);return this.findIndexBy(function(g){return g&&b.test(g[c])},null,e)},findIndexBy:function(e,d,j){var h=this,g=h.keys,b=h.items,c=j||0,a=b.length;for(;c<a;c++){if(e.call(d||h,b[c],g[c])){return c}}return -1},createValueMatcher:function(c,e,a,b){if(!c.exec){var d=Ext.String.escapeRegex;c=String(c);if(e===true){c=d(c)}else{c="^"+d(c);if(b===true){c+="$"}}c=new RegExp(c,a?"":"i")}return c},clone:function(){var e=this,g=new this.self(),d=e.keys,b=e.items,c=0,a=b.length;for(;c<a;c++){g.add(d[c],b[c])}g.getKey=e.getKey;return g}});Ext.define("Ext.util.Sorter",{direction:"ASC",constructor:function(a){var b=this;Ext.apply(b,a);b.updateSortFunction()},createSortFunction:function(b){var c=this,d=c.property,e=c.direction||"ASC",a=e.toUpperCase()=="DESC"?-1:1;return function(h,g){return a*b.call(c,h,g)}},defaultSorterFn:function(d,c){var b=this,a=b.transform,g=b.getRoot(d)[b.property],e=b.getRoot(c)[b.property];if(a){g=a(g);e=a(e)}return g>e?1:(g<e?-1:0)},getRoot:function(a){return this.root===undefined?a:a[this.root]},setDirection:function(b){var a=this;a.direction=b?b.toUpperCase():b;a.updateSortFunction()},toggle:function(){var a=this;a.direction=Ext.String.toggle(a.direction,"ASC","DESC");a.updateSortFunction()},updateSortFunction:function(a){var b=this;a=a||b.sorterFn||b.defaultSorterFn;b.sort=b.createSortFunction(a)}});Ext.define("Ext.util.Sortable",{isSortable:true,defaultSortDirection:"ASC",requires:["Ext.util.Sorter"],initSortable:function(){var a=this,b=a.sorters;a.sorters=new Ext.util.AbstractMixedCollection(false,function(c){return c.id||c.property});if(b){a.sorters.addAll(a.decodeSorters(b))}},sort:function(h,g,c,e){var d=this,i,b,a;if(Ext.isArray(h)){e=c;c=g;a=h}else{if(Ext.isObject(h)){e=c;c=g;a=[h]}else{if(Ext.isString(h)){i=d.sorters.get(h);if(!i){i={property:h,direction:g};a=[i]}else{if(g===undefined){i.toggle()}else{i.setDirection(g)}}}}}if(a&&a.length){a=d.decodeSorters(a);if(Ext.isString(c)){if(c==="prepend"){h=d.sorters.clone().items;d.sorters.clear();d.sorters.addAll(a);d.sorters.addAll(h)}else{d.sorters.addAll(a)}}else{d.sorters.clear();d.sorters.addAll(a)}}if(e!==false){d.onBeforeSort(a);h=d.sorters.items;if(h.length){d.doSort(d.generateComparator())}}return h},generateComparator:function(){var a=this.sorters.getRange();return a.length?this.createComparator(a):this.emptyComparator},createComparator:function(a){return function(d,c){var b=a[0].sort(d,c),g=a.length,e=1;for(;e<g;e++){b=b||a[e].sort.call(this,d,c)}return b}},emptyComparator:function(){return 0},onBeforeSort:Ext.emptyFn,decodeSorters:function(g){if(!Ext.isArray(g)){if(g===undefined){g=[]}else{g=[g]}}var d=g.length,h=Ext.util.Sorter,a=this.model?this.model.prototype.fields:null,e,b,c;for(c=0;c<d;c++){b=g[c];if(!(b instanceof h)){if(Ext.isString(b)){b={property:b}}Ext.applyIf(b,{root:this.sortRoot,direction:"ASC"});if(b.fn){b.sorterFn=b.fn}if(typeof b=="function"){b={sorterFn:b}}if(a&&!b.transform){e=a.get(b.property);b.transform=e?e.sortType:undefined}g[c]=new Ext.util.Sorter(b)}}return g},getSorters:function(){return this.sorters.items},getFirstSorter:function(){var c=this.sorters.items,a=c.length,b=0,d;for(;b<a;++b){d=c[b];if(!d.isGrouper){return d}}return null}});Ext.define("Ext.util.MixedCollection",{extend:"Ext.util.AbstractMixedCollection",mixins:{sortable:"Ext.util.Sortable"},constructor:function(){var a=this;a.callParent(arguments);a.addEvents("sort");a.mixins.sortable.initSortable.call(a)},doSort:function(a){this.sortBy(a)},_sort:function(l,a,k){var j=this,d,e,b=String(a).toUpperCase()=="DESC"?-1:1,h=[],m=j.keys,g=j.items;k=k||function(i,c){return i-c};for(d=0,e=g.length;d<e;d++){h[h.length]={key:m[d],value:g[d],index:d}}Ext.Array.sort(h,function(i,c){var n=k(i[l],c[l])*b;if(n===0){n=(i.index<c.index?-1:1)}return n});for(d=0,e=h.length;d<e;d++){g[d]=h[d].value;m[d]=h[d].key}j.fireEvent("sort",j)},sortBy:function(c){var h=this,b=h.items,g=h.keys,e=b.length,a=[],d;for(d=0;d<e;d++){a[d]={key:g[d],value:b[d],index:d}}Ext.Array.sort(a,function(j,i){var k=c(j.value,i.value);if(k===0){k=(j.index<i.index?-1:1)}return k});for(d=0;d<e;d++){b[d]=a[d].value;g[d]=a[d].key}h.fireEvent("sort",h,b,g)},findInsertionIndex:function(e,d){var g=this,b=g.items,i=0,a=b.length-1,c,h;if(!d){d=g.generateComparator()}while(i<=a){c=(i+a)>>1;h=d(e,b[c]);if(h>=0){i=c+1}else{if(h<0){a=c-1}}}return i},reorder:function(d){var h=this,b=h.items,c=0,g=b.length,a=[],e=[],i;h.suspendEvents();for(i in d){a[d[i]]=b[i]}for(c=0;c<g;c++){if(d[c]==undefined){e.push(b[c])}}for(c=0;c<g;c++){if(a[c]==undefined){a[c]=e.shift()}}h.clear();h.addAll(a);h.resumeEvents();h.fireEvent("sort",h)},sortByKey:function(a,b){this._sort("key",a,b||function(d,c){var g=String(d).toUpperCase(),e=String(c).toUpperCase();return g>e?1:(g<e?-1:0)})}});Ext.define("Ext.ZIndexManager",{alternateClassName:"Ext.WindowGroup",statics:{zBase:9000},constructor:function(a){var b=this;b.list={};b.zIndexStack=[];b.front=null;if(a){if(a.isContainer){a.on("resize",b._onContainerResize,b);b.zseed=Ext.Number.from(b.rendered?a.getEl().getStyle("zIndex"):undefined,b.getNextZSeed());b.targetEl=a.getTargetEl();b.container=a}else{Ext.EventManager.onWindowResize(b._onContainerResize,b);b.zseed=b.getNextZSeed();b.targetEl=Ext.get(a)}}else{Ext.EventManager.onWindowResize(b._onContainerResize,b);b.zseed=b.getNextZSeed();Ext.onDocumentReady(function(){b.targetEl=Ext.getBody()})}},getNextZSeed:function(){return(Ext.ZIndexManager.zBase+=10000)},setBase:function(b){this.zseed=b;var a=this.assignZIndices();this._activateLast();return a},assignZIndices:function(){var c=this.zIndexStack,b=c.length,e=0,g=this.zseed,d;for(;e<b;e++){d=c[e];if(d&&!d.hidden){g=d.setZIndex(g)}}this._activateLast();return g},_setActiveChild:function(b,a){var c=this.front;if(b!==c){if(c&&!c.destroying){c.setActive(false,b)}this.front=b;if(b&&b!=a){b.setActive(true);if(b.modal){this._showModalMask(b)}}}},onComponentHide:function(a){a.setActive(false);this._activateLast()},_activateLast:function(){var e=this,a=e.zIndexStack,d=a.length-1,c=e.front,b;e.front=undefined;for(;d>=0&&a[d].hidden;--d){}if((b=a[d])){e._setActiveChild(b,c);if(b.modal){return}}for(;d>=0;--d){b=a[d];if(b.isVisible()&&b.modal){e._showModalMask(b);return}}e._hideModalMask()},_showModalMask:function(a){var c=this,e=a.el.getStyle("zIndex")-4,b=a.floatParent?a.floatParent.getTargetEl():a.container,d=b.getBox();if(b.dom===document.body){d.height=Math.max(document.body.scrollHeight,Ext.dom.Element.getDocumentHeight());d.width=Math.max(document.body.scrollWidth,d.width)}if(!c.mask){c.mask=Ext.getBody().createChild({cls:Ext.baseCSSPrefix+"mask"});c.mask.setVisibilityMode(Ext.Element.DISPLAY);c.mask.on("click",c._onMaskClick,c)}c.mask.maskTarget=b;b.addCls(Ext.baseCSSPrefix+"body-masked");c.mask.setStyle("zIndex",e);c.mask.show();c.mask.setBox(d)},_hideModalMask:function(){var a=this.mask;if(a&&a.isVisible()){a.maskTarget.removeCls(Ext.baseCSSPrefix+"body-masked");a.maskTarget=undefined;a.hide()}},_onMaskClick:function(){if(this.front){this.front.focus()}},_onContainerResize:function(){var a=this.mask,b,c;if(a&&a.isVisible()){a.hide();b=a.maskTarget;if(b.dom===document.body){c={height:Math.max(document.body.scrollHeight,Ext.dom.Element.getDocumentHeight()),width:Math.max(document.body.scrollWidth,document.documentElement.clientWidth)}}else{c=b.getViewSize(true)}a.setSize(c);a.show()}},register:function(a){var b=this;if(a.zIndexManager){a.zIndexManager.unregister(a)}a.zIndexManager=b;b.list[a.id]=a;b.zIndexStack.push(a);a.on("hide",b.onComponentHide,b)},unregister:function(a){var b=this,c=b.list;delete a.zIndexManager;if(c&&c[a.id]){delete c[a.id];a.un("hide",b.onComponentHide);Ext.Array.remove(b.zIndexStack,a);b._activateLast()}},get:function(a){return a.isComponent?a:this.list[a]},bringToFront:function(b){var c=this,a=false,d=c.zIndexStack;b=c.get(b);if(b!==c.front){Ext.Array.remove(d,b);if(b.preventBringToFront){d.unshift(b)}else{d.push(b)}c.assignZIndices();a=true;this.front=b}if(a&&b.modal){c._showModalMask(b)}return a},sendToBack:function(a){var b=this;a=b.get(a);Ext.Array.remove(b.zIndexStack,a);b.zIndexStack.unshift(a);b.assignZIndices();this._activateLast();return a},hideAll:function(){var b=this.list,a,c;for(c in b){if(b.hasOwnProperty(c)){a=b[c];if(a.isComponent&&a.isVisible()){a.hide()}}}},hide:function(){var g=this,c=g.mask,e=0,b=g.zIndexStack,a=b.length,d;g.tempHidden=g.tempHidden||[];for(;e<a;e++){d=b[e];if(d.isVisible()){g.tempHidden.push(d);d.el.hide()}}if(c){c.hide()}},show:function(){var e=this,b=e.mask,d=0,g=e.tempHidden,a=g?g.length:0,c;for(;d<a;d++){c=g[d];c.el.show();c.setPosition(c.x,c.y)}e.tempHidden.length=0;if(b){b.show();b.alignTo(b.maskTarget,"tl-tl")}},getActive:function(){return this.front},getBy:function(g,e){var h=[],d=0,b=this.zIndexStack,a=b.length,c;for(;d<a;d++){c=b[d];if(g.call(e||c,c)!==false){h.push(c)}}return h},each:function(c,b){var d=this.list,e,a;for(e in d){if(d.hasOwnProperty(e)){a=d[e];if(a.isComponent&&c.call(b||a,a)===false){return}}}},eachBottomUp:function(g,e){var b=this.zIndexStack,d=0,a=b.length,c;for(;d<a;d++){c=b[d];if(c.isComponent&&g.call(e||c,c)===false){return}}},eachTopDown:function(e,d){var a=this.zIndexStack,c=a.length,b;for(;c-->0;){b=a[c];if(b.isComponent&&e.call(d||b,b)===false){return}}},destroy:function(){var b=this,c=b.list,a,d;for(d in c){if(c.hasOwnProperty(d)){a=c[d];if(a.isComponent){a.destroy()}}}delete b.zIndexStack;delete b.list;delete b.container;delete b.targetEl}},function(){Ext.WindowManager=Ext.WindowMgr=new this()});Ext.define("Ext.container.AbstractContainer",{extend:"Ext.Component",requires:["Ext.util.MixedCollection","Ext.layout.container.Auto","Ext.ZIndexManager"],renderTpl:"{%this.renderContainer(out,values)%}",suspendLayout:false,autoDestroy:true,defaultType:"panel",detachOnRemove:true,isContainer:true,layoutCounter:0,baseCls:Ext.baseCSSPrefix+"container",bubbleEvents:["add","remove"],defaultLayoutType:"auto",initComponent:function(){var a=this;a.addEvents("afterlayout","beforeadd","beforeremove","add","remove");a.callParent();a.getLayout();a.initItems()},initItems:function(){var b=this,a=b.items;b.items=new Ext.util.AbstractMixedCollection(false,b.getComponentId);if(a){if(!Ext.isArray(a)){a=[a]}b.add(a)}},getFocusEl:function(){return this.getTargetEl()},finishRenderChildren:function(){this.callParent();var a=this.getLayout();if(a){a.finishRender()}},beforeRender:function(){var b=this,a=b.getLayout();b.callParent();if(!a.initialized){a.initLayout()}},setupRenderTpl:function(b){var a=this.getLayout();this.callParent(arguments);a.setupRenderTpl(b)},setLayout:function(b){var a=this.layout;if(a&&a.isLayout&&a!=b){a.setOwner(null)}this.layout=b;b.setOwner(this)},getLayout:function(){var a=this;if(!a.layout||!a.layout.isLayout){a.setLayout(Ext.layout.Layout.create(a.layout,a.self.prototype.layout||"autocontainer"))}return a.layout},doLayout:function(){this.updateLayout();return this},afterLayout:function(b){var a=this;++a.layoutCounter;if(a.hasListeners.afterlayout){a.fireEvent("afterlayout",a,b)}},prepareItems:function(b,d){if(Ext.isArray(b)){b=b.slice()}else{b=[b]}var g=this,c=0,a=b.length,e;for(;c<a;c++){e=b[c];if(e==null){Ext.Array.erase(b,c,1);--c;--a}else{if(d){e=this.applyDefaults(e)}e.isContained=g;b[c]=g.lookupComponent(e);delete e.isContained}}return b},applyDefaults:function(a){var b=this.defaults;if(b){if(Ext.isFunction(b)){b=b.call(this,a)}if(Ext.isString(a)){a=Ext.ComponentManager.get(a)}Ext.applyIf(a,b)}return a},lookupComponent:function(a){return(typeof a=="string")?Ext.ComponentManager.get(a):Ext.ComponentManager.create(a,this.defaultType)},getComponentId:function(a){return a.getItemId()},add:function(){var j=this,g=Ext.Array.slice(arguments),d=(typeof g[0]=="number")?g.shift():-1,c=j.getLayout(),l,h,b,a,m,k,e;if(g.length==1&&Ext.isArray(g[0])){h=g[0];l=true}else{h=g}e=h=j.prepareItems(h,true);a=h.length;if(j.rendered){Ext.suspendLayouts()}if(!l&&a==1){e=h[0]}for(b=0;b<a;b++){m=h[b];k=(d<0)?j.items.length:(d+b);if(m.floating){j.floatingItems=j.floatingItems||new Ext.util.MixedCollection();j.floatingItems.add(m);m.onAdded(j,k)}else{if((!j.hasListeners.beforeadd||j.fireEvent("beforeadd",j,m,k)!==false)&&j.onBeforeAdd(m)!==false){j.items.insert(k,m);m.onAdded(j,k);j.onAdd(m,k);c.onAdd(m,k);if(j.hasListeners.add){j.fireEvent("add",j,m,k)}}}}j.updateLayout();if(j.rendered){Ext.resumeLayouts(true)}return e},onAdd:Ext.emptyFn,onRemove:Ext.emptyFn,insert:function(b,a){return this.add(b,a)},move:function(b,d){var a=this.items,c;c=a.removeAt(b);if(c===false){return false}a.insert(d,c);this.doLayout();return c},onBeforeAdd:function(c){var b=this,a=c.border;if(c.ownerCt&&c.ownerCt!==b){c.ownerCt.remove(c,false)}if(b.border===false||b.border===0){c.border=Ext.isDefined(a)&&a!==false&&a!==0}},remove:function(a,b){var d=this,e=d.getComponent(a);if(e&&(!d.hasListeners.beforeremove||d.fireEvent("beforeremove",d,e)!==false)){d.doRemove(e,b);if(d.hasListeners.remove){d.fireEvent("remove",d,e)}if(!d.destroying){d.doLayout()}}return e},doRemove:function(c,b){var e=this,d=e.layout,a=d&&e.rendered,g=b===true||(b!==false&&e.autoDestroy);b=b===true||(b!==false&&e.autoDestroy);e.items.remove(c);if(a){if(d.running){Ext.AbstractComponent.cancelLayout(c,g)}d.onRemove(c,g)}c.onRemoved(g);e.onRemove(c,g);if(g){c.destroy()}else{if(a){d.afterRemove(c)}if(e.detachOnRemove&&c.rendered){Ext.getDetachedBody().appendChild(c.getEl())}}},removeAll:function(c){var h=this,e=h.items.items.slice(),b=[],d=0,a=e.length,g;h.suspendLayouts();for(;d<a;d++){g=e[d];h.remove(g,c);if(g.ownerCt!==h){b.push(g)}}h.resumeLayouts(!!a);return b},getRefItems:function(c){var h=this,d=h.items.items,b=d.length,e=0,g,a=[];for(;e<b;e++){g=d[e];a.push(g);if(c&&g.getRefItems){a.push.apply(a,g.getRefItems(true))}}if(h.floatingItems){a.push.apply(a,h.floatingItems.items)}return a},cascade:function(l,m,a){var k=this,e=k.items?k.items.items:[],g=e.length,d=0,j,h=a?a.concat(k):[k],b=h.length-1;if(l.apply(m||k,h)!==false){for(;d<g;d++){j=e[d];if(j.cascade){j.cascade(l,m,a)}else{h[b]=j;l.apply(m||e,h)}}}return this},isAncestor:function(a){while(a){if(a.ownerCt===this){return true}a=a.ownerCt}},getComponent:function(a){if(Ext.isObject(a)){a=a.getItemId()}return this.items.get(a)},query:function(a){a=a||"*";return Ext.ComponentQuery.query(a,this)},queryBy:function(g,e){var c=[],b=this.getRefItems(true),d=0,a=b.length,h;for(;d<a;++d){h=b[d];if(g.call(e||h,h)!==false){c.push(h)}}return c},queryById:function(a){return this.down("#"+a)},child:function(a){a=a||"";return this.query("> "+a)[0]||null},nextChild:function(e,b){var c=this,a,d=c.items.indexOf(e);if(d!==-1){a=b?Ext.ComponentQuery(b,c.items.items.slice(d+1)):c.items.getAt(d+1);if(!a&&c.ownerCt){a=c.ownerCt.nextChild(c,b)}}return a},prevChild:function(e,b){var c=this,a,d=c.items.indexOf(e);if(d!==-1){a=b?Ext.ComponentQuery(b,c.items.items.slice(d+1)):c.items.getAt(d+1);if(!a&&c.ownerCt){a=c.ownerCt.nextChild(c,b)}}return a},down:function(a){return this.query(a)[0]||null},enable:function(){this.callParent(arguments);var d=this.getChildItemsToDisable(),c=d.length,b,a;for(a=0;a<c;a++){b=d[a];if(b.resetDisable){b.enable()}}return this},disable:function(){this.callParent(arguments);var d=this.getChildItemsToDisable(),c=d.length,b,a;for(a=0;a<c;a++){b=d[a];if(b.resetDisable!==false&&!b.disabled){b.disable();b.resetDisable=true}}return this},getChildItemsToDisable:function(){return this.query("[isFormField],button")},beforeLayout:function(){return true},beforeDestroy:function(){var b=this,a=b.items,d;if(a){while((d=a.first())){b.doRemove(d,true)}}Ext.destroy(b.layout);b.callParent()}});Ext.define("Ext.container.Container",{extend:"Ext.container.AbstractContainer",alias:"widget.container",alternateClassName:"Ext.Container",fireHierarchyEvent:function(a){this.hierarchyEventSource.fireEvent(a,this)},afterHide:function(){this.callParent(arguments);this.fireHierarchyEvent("hide")},afterShow:function(){this.callParent(arguments);this.fireHierarchyEvent("show")},onAdded:function(){this.callParent(arguments);if(this.hierarchyEventSource.hasListeners.added){this.fireHierarchyEvent("added")}},getChildByElement:function(e,a){var h,c,b=0,d=this.getRefItems(),g=d.length;e=Ext.getDom(e);for(;b<g;b++){h=d[b];c=h.getEl();if(c&&((c.dom===e)||c.contains(e))){return(a&&h.getChildByElement)?h.getChildByElement(e,a):h}}return null}},function(){this.hierarchyEventSource=this.prototype.hierarchyEventSource=new Ext.util.Observable({events:{hide:true,show:true,collapse:true,expand:true,added:true}})});Ext.define("Ext.Editor",{extend:"Ext.container.Container",alias:"widget.editor",requires:["Ext.layout.container.Editor"],layout:"editor",allowBlur:true,revertInvalid:true,value:"",alignment:"c-c?",offsets:[0,0],shadow:"frame",constrain:false,swallowKeys:true,completeOnEnter:true,cancelOnEsc:true,updateEl:false,hidden:true,baseCls:Ext.baseCSSPrefix+"editor",initComponent:function(){var a=this,b=a.field=Ext.ComponentManager.create(a.field,"textfield");Ext.apply(b,{inEditor:true,msgTarget:b.msgTarget=="title"?"title":"qtip"});a.mon(b,{scope:a,blur:{fn:a.onFieldBlur,delay:1},specialkey:a.onSpecialKey});if(b.grow){a.mon(b,"autosize",a.onFieldAutosize,a,{delay:1})}a.floating={constrain:a.constrain};a.items=b;a.callParent(arguments);a.addEvents("beforestartedit","startedit","beforecomplete","complete","canceledit","specialkey")},onFieldAutosize:function(){this.updateLayout()},afterRender:function(b,a){var c=this,e=c.field,d=e.inputEl;c.callParent(arguments);if(d){d.dom.name="";if(c.swallowKeys){d.swallowEvent(["keypress","keydown"])}}},onSpecialKey:function(g,e){var d=this,b=e.getKey(),a=d.completeOnEnter&&b==e.ENTER,c=d.cancelOnEsc&&b==e.ESC;if(a||c){e.stopEvent();Ext.defer(function(){if(a){d.completeEdit()}else{d.cancelEdit()}if(g.triggerBlur){g.triggerBlur(e)}},10)}d.fireEvent("specialkey",d,g,e)},startEdit:function(a,c){var b=this,d=b.field;b.completeEdit();b.boundEl=Ext.get(a);c=Ext.isDefined(c)?c:Ext.String.trim(b.boundEl.dom.innerText||b.boundEl.dom.innerHTML);if(!b.rendered){b.render(b.parentEl||document.body)}if(b.fireEvent("beforestartedit",b,b.boundEl,c)!==false){b.startValue=c;b.show();d.suspendEvents();d.reset();d.setValue(c);d.resumeEvents();b.realign(true);d.focus(false,10);if(d.autoSize){d.autoSize()}b.editing=true}},realign:function(a){var b=this;if(a===true){b.updateLayout()}b.alignTo(b.boundEl,b.alignment,b.offsets)},completeEdit:function(a){var b=this,d=b.field,c;if(!b.editing){return}if(d.assertValue){d.assertValue()}c=b.getValue();if(!d.isValid()){if(b.revertInvalid!==false){b.cancelEdit(a)}return}if(String(c)===String(b.startValue)&&b.ignoreNoChange){b.hideEdit(a);return}if(b.fireEvent("beforecomplete",b,c,b.startValue)!==false){c=b.getValue();if(b.updateEl&&b.boundEl){b.boundEl.update(c)}b.hideEdit(a);b.fireEvent("complete",b,c,b.startValue)}},onShow:function(){var a=this;a.callParent(arguments);if(a.hideEl!==false){a.boundEl.hide()}a.fireEvent("startedit",a,a.boundEl,a.startValue)},cancelEdit:function(a){var c=this,b=c.startValue,e=c.field,d;if(c.editing){d=c.getValue();e.suspendEvents();c.setValue(b);e.resumeEvents();c.hideEdit(a);c.fireEvent("canceledit",c,d,b)}},hideEdit:function(a){if(a!==true){this.editing=false;this.hide()}},onFieldBlur:function(d,c){var a=this,b;if(a.allowBlur===true&&a.editing&&a.selectSameEditor!==true){a.completeEdit()}if(c&&Ext.fly(b=c.getTarget()).focusable()){b.focus()}},onHide:function(){var a=this,b=a.field;if(a.editing){a.completeEdit();return}if(b.hasFocus){b.blur()}if(b.collapse){b.collapse()}if(a.hideEl!==false){a.boundEl.show()}a.callParent(arguments)},setValue:function(a){this.field.setValue(a)},getValue:function(){return this.field.getValue()},beforeDestroy:function(){var a=this;Ext.destroy(a.field);delete a.field;delete a.parentEl;delete a.boundEl;a.callParent(arguments)}});Ext.define("Ext.util.KeyMap",{alternateClassName:"Ext.KeyMap",eventName:"keydown",constructor:function(a){var b=this;if((arguments.length!==1)||(typeof a==="string")||a.dom||a.tagName||a===document||a.isComponent){b.legacyConstructor.apply(b,arguments);return}Ext.apply(b,a);b.bindings=[];if(!b.target.isComponent){b.target=Ext.get(b.target)}if(b.binding){b.addBinding(b.binding)}else{if(a.key){b.addBinding(a)}}b.enable()},legacyConstructor:function(b,d,a){var c=this;Ext.apply(c,{target:Ext.get(b),eventName:a||c.eventName,bindings:[]});if(d){c.addBinding(d)}c.enable()},addBinding:function(h){var g=h.key,j=false,d,e,b,c,a;if(Ext.isArray(h)){for(c=0,a=h.length;c<a;c++){this.addBinding(h[c])}return}if(Ext.isString(g)){e=[];b=g.toUpperCase();for(c=0,a=b.length;c<a;++c){e.push(b.charCodeAt(c))}g=e;j=true}if(!Ext.isArray(g)){g=[g]}if(!j){for(c=0,a=g.length;c<a;++c){d=g[c];if(Ext.isString(d)){g[c]=d.toUpperCase().charCodeAt(0)}}}this.bindings.push(Ext.apply({keyCode:g},h))},handleTargetEvent:(function(){var a=/input|textarea/i;return function(g){var e=this,j,c,b,h,d;if(this.enabled){j=this.bindings;c=0;b=j.length;g=e.processEvent.apply(e||e.processEventScope,arguments);if(e.ignoreInputFields){h=g.target;d=h.contentEditable;if(a.test(h.tagName)||(d===""||d==="true")){return}}if(!g.getKey){return g}for(;c<b;++c){this.processBinding(j[c],g)}}}}()),processEvent:function(a){return a},processBinding:function(g,a){if(this.checkModifiers(g,a)){var h=a.getKey(),k=g.fn||g.handler,l=g.scope||this,j=g.keyCode,b=g.defaultEventAction,c,e,d=new Ext.EventObjectImpl(a);for(c=0,e=j.length;c<e;++c){if(h===j[c]){if(k.call(l,h,a)!==true&&b){d[b]()}break}}}},checkModifiers:function(j,g){var d=["shift","ctrl","alt"],c=0,a=d.length,h,b;for(;c<a;++c){b=d[c];h=j[b];if(!(h===undefined||(h===g[b+"Key"]))){return false}}return true},on:function(b,d,c){var h,a,e,g;if(Ext.isObject(b)&&!Ext.isArray(b)){h=b.key;a=b.shift;e=b.ctrl;g=b.alt}else{h=b}this.addBinding({key:h,shift:a,ctrl:e,alt:g,fn:d,scope:c})},isEnabled:function(){return this.enabled},enable:function(){var a=this;if(!a.enabled){a.target.on(a.eventName,a.handleTargetEvent,a);a.enabled=true}},disable:function(){var a=this;if(a.enabled){a.target.removeListener(a.eventName,a.handleTargetEvent,a);a.enabled=false}},setDisabled:function(a){if(a){this.disable()}else{this.enable()}},destroy:function(c){var a=this,b=a.target;a.bindings=[];a.disable();if(c===true){if(b.isComponent){b.destroy()}else{b.remove()}}delete a.target}});Ext.define("Ext.util.KeyNav",{alternateClassName:"Ext.KeyNav",requires:["Ext.util.KeyMap"],statics:{keyOptions:{left:37,right:39,up:38,down:40,space:32,pageUp:33,pageDown:34,del:46,backspace:8,home:36,end:35,enter:13,esc:27,tab:9}},constructor:function(a){var b=this;if(arguments.length===2){b.legacyConstructor.apply(b,arguments);return}b.setConfig(a)},legacyConstructor:function(b,a){this.setConfig(Ext.apply({target:b},a))},setConfig:function(b){var e=this,c={target:b.target,ignoreInputFields:b.ignoreInputFields,eventName:e.getKeyEvent("forceKeyDown" in b?b.forceKeyDown:e.forceKeyDown,b.eventName)},g,a,i,d,h;if(e.map){e.map.destroy()}if(b.processEvent){c.processEvent=b.processEvent;c.processEventScope=b.processEventScope||e}g=e.map=new Ext.util.KeyMap(c);a=Ext.util.KeyNav.keyOptions;i=b.scope||e;for(d in a){if(a.hasOwnProperty(d)){if(h=b[d]){if(typeof h==="function"){h={handler:h,defaultAction:(b.defaultEventAction!==undefined)?b.defaultEventAction:e.defaultEventAction}}g.addBinding({key:a[d],handler:Ext.Function.bind(e.handleEvent,h.scope||i,h.handler||h.fn,true),defaultEventAction:(h.defaultEventAction!==undefined)?h.defaultAction:e.defaultEventAction})}}}g.disable();if(!b.disabled){g.enable()}},handleEvent:function(c,b,a){return a.call(this,b)},disabled:false,defaultEventAction:"stopEvent",forceKeyDown:false,eventName:"keypress",destroy:function(a){this.map.destroy(a);delete this.map},enable:function(){this.map.enable();this.disabled=false},disable:function(){this.map.disable();this.disabled=true},setDisabled:function(a){this.map.setDisabled(a);this.disabled=a},getKeyEvent:function(b,a){if(b||(Ext.EventManager.useKeyDown&&!a)){return"keydown"}else{return a||this.eventName}}});Ext.define("Ext.FocusManager",{singleton:true,alternateClassName:["Ext.FocusMgr"],mixins:{observable:"Ext.util.Observable"},requires:["Ext.AbstractComponent","Ext.Component","Ext.ComponentManager","Ext.ComponentQuery","Ext.util.HashMap","Ext.util.KeyNav"],enabled:false,focusElementCls:Ext.baseCSSPrefix+"focus-element",focusFrameCls:Ext.baseCSSPrefix+"focus-frame",whitelist:["textfield"],constructor:function(a){var b=this,c=Ext.ComponentQuery;b.mixins.observable.constructor.call(b,a);b.addEvents("beforecomponentfocus","componentfocus","disable","enable");b.focusTask=new Ext.util.DelayedTask(b.handleComponentFocus,b);Ext.override(Ext.AbstractComponent,{onFocus:function(){this.callParent(arguments);if(b.enabled&&this.hasFocus){Array.prototype.unshift.call(arguments,this);b.onComponentFocus.apply(b,arguments)}},onBlur:function(){this.callParent(arguments);if(b.enabled&&!this.hasFocus){Array.prototype.unshift.call(arguments,this);b.onComponentBlur.apply(b,arguments)}},onDestroy:function(){this.callParent(arguments);if(b.enabled){Array.prototype.unshift.call(arguments,this);b.onComponentDestroy.apply(b,arguments)}}});Ext.override(Ext.Component,{afterHide:function(){this.callParent(arguments);if(b.enabled){Array.prototype.unshift.call(arguments,this);b.onComponentHide.apply(b,arguments)}}});b.keyNav=new Ext.util.KeyNav(Ext.getDoc(),{disabled:true,scope:b,backspace:b.focusLast,enter:b.navigateIn,esc:b.navigateOut,tab:b.navigateSiblings,space:b.navigateIn,del:b.focusLast,left:b.navigateSiblings,right:b.navigateSiblings,down:b.navigateSiblings,up:b.navigateSiblings});b.focusData={};b.subscribers=new Ext.util.HashMap();b.focusChain={};Ext.apply(c.pseudos,{focusable:function(e){var d=e.length,h=[],g=0,j;for(;g<d;g++){j=e[g];if(j.isFocusable()){h.push(j)}}return h},nextFocus:function(g,e,j){j=j||1;e=parseInt(e,10);var d=g.length,h=e,k;for(;;){if((h+=j)>=d){h=0}else{if(h<0){h=d-1}}if(h===e){return[]}if((k=g[h]).isFocusable()){return[k]}}return[]},prevFocus:function(e,d){return this.nextFocus(e,d,-1)},root:function(e){var d=e.length,h=[],g=0,j;for(;g<d;g++){j=e[g];if(!j.ownerCt){h.push(j)}}return h}})},addXTypeToWhitelist:function(b){var a=this;if(Ext.isArray(b)){Ext.Array.forEach(b,a.addXTypeToWhitelist,a);return}if(!Ext.Array.contains(a.whitelist,b)){a.whitelist.push(b)}},clearComponent:function(a){clearTimeout(this.cmpFocusDelay);if(!a.isDestroyed){a.blur()}},disable:function(){var a=this;if(!a.enabled){return}delete a.options;a.enabled=false;a.removeDOM();a.keyNav.disable();a.fireEvent("disable",a)},enable:function(a){var b=this;if(a===true){a={focusFrame:true}}b.options=a=a||{};if(b.enabled){return}b.enabled=true;b.initDOM(a);b.keyNav.enable();b.focusEl.focus();delete b.focusedCmp;b.fireEvent("enable",b)},focusLast:function(b){var a=this;if(a.isWhitelisted(a.focusedCmp)){return true}if(a.previousFocusedCmp){a.previousFocusedCmp.focus()}},getRootComponents:function(){var a=this,c=Ext.ComponentQuery,b=c.query(":focusable:root:not([floating])"),d=c.query(":focusable:root[floating]");d.sort(function(g,e){return g.el.getZIndex()>e.el.getZIndex()});return d.concat(b)},initDOM:function(c){var g=this,b=g.focusFrameCls,e=Ext.ComponentQuery.query("{getFocusEl()}:not([focusListenerAdded])"),d=0,a=e.length;if(!Ext.isReady){return Ext.onReady(g.initDOM,g)}for(;d<a;d++){e[d].addFocusListener()}if(!g.focusEl){g.focusEl=Ext.getBody();g.focusEl.dom.tabIndex=-1}if(!g.focusFrame&&c.focusFrame){g.focusFrame=Ext.getBody().createChild({cls:b,children:[{cls:b+"-top"},{cls:b+"-bottom"},{cls:b+"-left"},{cls:b+"-right"}],style:"top: -100px; left: -100px;"});g.focusFrame.setVisibilityMode(Ext.Element.DISPLAY);g.focusFrame.hide().setLeftTop(0,0)}},isWhitelisted:function(a){return a&&Ext.Array.some(this.whitelist,function(b){return a.isXType(b)})},navigateIn:function(g){var c=this,a=c.focusedCmp,b,d;if(c.isWhitelisted(a)){return true}if(!a){b=c.getRootComponents()[0];if(b){if(b.getFocusEl()===c.focusEl){c.focusEl.blur()}b.focus()}}else{d=a.hasFocus?Ext.ComponentQuery.query(">:focusable",a)[0]:a;if(d){d.focus()}else{if(Ext.isFunction(a.onClick)){g.button=0;a.onClick(g);if(a.isVisible(true)){a.focus()}else{c.navigateOut()}}}}},navigateOut:function(c){var b=this,a;if(!b.focusedCmp||!(a=b.focusedCmp.up(":focusable"))){b.focusEl.focus()}else{a.focus()}return true},navigateSiblings:function(i,b,o){var j=this,a=b||j,p=i.getKey(),g=Ext.EventObject,k=i.shiftKey||p==g.LEFT||p==g.UP,c=p==g.LEFT||p==g.RIGHT||p==g.UP||p==g.DOWN,h=k?"prev":"next",n,d,m,l;m=(a.focusedCmp&&a.focusedCmp.comp)||a.focusedCmp;if(!m&&!o){return true}if(c&&j.isWhitelisted(m)){return true}if(!m||m.is(":root")){l=j.getRootComponents()}else{o=o||m.up();if(o){l=o.getRefItems()}}if(l){n=m?Ext.Array.indexOf(l,m):-1;d=Ext.ComponentQuery.query(":"+h+"Focus("+n+")",l)[0];if(d&&m!==d){d.focus();return d}}},onComponentBlur:function(b,c){var a=this;if(a.focusedCmp===b){a.previousFocusedCmp=b;delete a.focusedCmp}if(a.focusFrame){a.focusFrame.hide()}},onComponentFocus:function(d,g){var c=this,a=c.focusChain,b;if(!d.isFocusable()){c.clearComponent(d);if(a[d.id]){return}b=d.up();if(b){a[d.id]=true;b.focus()}return}c.focusChain={};c.focusTask.delay(10,null,null,[d,d.getFocusEl()])},handleComponentFocus:function(m,i){var k=this,p,a,d,h,o,b,l,e,g,c,n,j;if(k.fireEvent("beforecomponentfocus",k,m,k.previousFocusedCmp)===false){k.clearComponent(m);return}k.focusedCmp=m;if(k.shouldShowFocusFrame(m)){p="."+k.focusFrameCls+"-";a=k.focusFrame;h=i.getPageBox();o=h.top;b=h.left;l=h.width;e=h.height;g=a.child(p+"top");c=a.child(p+"bottom");n=a.child(p+"left");j=a.child(p+"right");g.setWidth(l).setLeftTop(b,o);c.setWidth(l).setLeftTop(b,o+e-2);n.setHeight(e-2).setLeftTop(b,o+2);j.setHeight(e-2).setLeftTop(b+l-2,o+2);a.show()}k.fireEvent("componentfocus",k,m,k.previousFocusedCmp)},onComponentHide:function(e){var d=this,b=false,a=d.focusedCmp,c;if(a){b=e.hasFocus||(e.isContainer&&e.isAncestor(d.focusedCmp))}d.clearComponent(e);if(b&&(c=e.up(":focusable"))){c.focus()}else{d.focusEl.focus()}},onComponentDestroy:function(){},removeDOM:function(){var a=this;if(a.enabled||a.subscribers.length){return}Ext.destroy(a.focusFrame);delete a.focusEl;delete a.focusFrame},removeXTypeFromWhitelist:function(b){var a=this;if(Ext.isArray(b)){Ext.Array.forEach(b,a.removeXTypeFromWhitelist,a);return}Ext.Array.remove(a.whitelist,b)},setupSubscriberKeys:function(a,g){var e=this,d=a.getFocusEl(),c=g.scope,b={backspace:e.focusLast,enter:e.navigateIn,esc:e.navigateOut,scope:e},h=function(i){if(e.focusedCmp===a){return e.navigateSiblings(i,e,a)}else{return e.navigateSiblings(i)}};Ext.iterate(g,function(j,i){b[j]=function(l){var k=h(l);if(Ext.isFunction(i)&&i.call(c||a,l,k)===true){return true}return k}},e);return new Ext.util.KeyNav(d,b)},shouldShowFocusFrame:function(c){var b=this,a=b.options||{},e=c.getFocusEl(),d=Ext.getDom(e).tagName;if(!b.focusFrame||!c){return false}if(a.focusFrame){return true}if(b.focusData[c.id].focusFrame){return true}return false}});Ext.define("Ext.Img",{extend:"Ext.Component",alias:["widget.image","widget.imagecomponent"],autoEl:"img",src:"",alt:"",imgCls:"",getElConfig:function(){var c=this,b=c.callParent(),a;if(c.autoEl=="img"){a=b}else{b.cn=[a={tag:"img",id:c.id+"-img"}]}if(c.imgCls){a.cls=(a.cls?a.cls+" ":"")+c.imgCls}a.src=c.src||Ext.BLANK_IMAGE_URL;if(c.alt){a.alt=c.alt}return b},onRender:function(){var b=this,a;b.callParent(arguments);a=b.el;b.imgEl=(b.autoEl=="img")?a:a.getById(b.id+"-img")},onDestroy:function(){Ext.destroy(this.imgEl);this.imgEl=null;this.callParent()},setSrc:function(c){var a=this,b=a.imgEl;a.src=c;if(b){b.dom.src=c||Ext.BLANK_IMAGE_URL}}});Ext.define("Ext.Layer",{extend:"Ext.Element",uses:["Ext.Shadow"],statics:{shims:[]},isLayer:true,constructor:function(b,a){b=b||{};var c=this,d=Ext.DomHelper,g=b.parentEl,e=g?Ext.getDom(g):document.body,h=b.hideMode;if(a){c.dom=Ext.getDom(a)}if(!c.dom){c.dom=d.append(e,b.dh||{tag:"div",cls:Ext.baseCSSPrefix+"layer"})}else{c.addCls(Ext.baseCSSPrefix+"layer");if(!c.dom.parentNode){e.appendChild(c.dom)}}if(b.id){c.id=c.dom.id=b.id}else{c.id=Ext.id(c.dom)}Ext.Element.addToCache(c);if(b.cls){c.addCls(b.cls)}c.constrain=b.constrain!==false;if(h){c.setVisibilityMode(Ext.Element[h.toUpperCase()]);if(c.visibilityMode==Ext.Element.ASCLASS){c.visibilityCls=b.visibilityCls}}else{if(b.useDisplay){c.setVisibilityMode(Ext.Element.DISPLAY)}else{c.setVisibilityMode(Ext.Element.VISIBILITY)}}if(b.shadow){c.shadowOffset=b.shadowOffset||4;c.shadow=new Ext.Shadow({offset:c.shadowOffset,mode:b.shadow});c.disableShadow()}else{c.shadowOffset=0}c.useShim=b.shim!==false&&Ext.useShims;if(b.hidden===true){c.hide()}else{c.show()}},getZIndex:function(){return parseInt((this.getShim()||this).getStyle("z-index"),10)},getShim:function(){var b=this,c,a;if(!b.useShim){return null}if(!b.shim){c=b.self.shims.shift();if(!c){c=b.createShim();c.enableDisplayMode("block");c.hide()}a=b.dom.parentNode;if(c.dom.parentNode!=a){a.insertBefore(c.dom,b.dom)}b.shim=c}return b.shim},hideShim:function(){var a=this;if(a.shim){a.shim.setDisplayed(false);a.self.shims.push(a.shim);delete a.shim}},disableShadow:function(){var a=this;if(a.shadow&&!a.shadowDisabled){a.shadowDisabled=true;a.shadow.hide();a.lastShadowOffset=a.shadowOffset;a.shadowOffset=0}},enableShadow:function(a){var b=this;if(b.shadow&&b.shadowDisabled){b.shadowDisabled=false;b.shadowOffset=b.lastShadowOffset;delete b.lastShadowOffset;if(a){b.sync(true)}}},sync:function(b){var j=this,n=j.shadow,i,e,a,d,c,o,m,g,k;if(!j.updating&&j.isVisible()&&(n||j.useShim)){d=j.getShim();c=j.getLocalX();o=j.getLocalY();m=j.dom.offsetWidth;g=j.dom.offsetHeight;if(n&&!j.shadowDisabled){if(b&&!n.isVisible()){n.show(j)}else{n.realign(c,o,m,g)}if(d){k=d.getStyle("z-index");if(k>j.zindex){j.shim.setStyle("z-index",j.zindex-2)}d.show();if(n.isVisible()){i=n.el.getXY();e=d.dom.style;a=n.el.getSize();if(Ext.supports.CSS3BoxShadow){a.height+=6;a.width+=4;i[0]-=2;i[1]-=4}e.left=(i[0])+"px";e.top=(i[1])+"px";e.width=(a.width)+"px";e.height=(a.height)+"px"}else{d.setSize(m,g);d.setLeftTop(c,o)}}}else{if(d){k=d.getStyle("z-index");if(k>j.zindex){j.shim.setStyle("z-index",j.zindex-2)}d.show();d.setSize(m,g);d.setLeftTop(c,o)}}}return j},remove:function(){this.hideUnders();this.callParent()},beginUpdate:function(){this.updating=true},endUpdate:function(){this.updating=false;this.sync(true)},hideUnders:function(){if(this.shadow){this.shadow.hide()}this.hideShim()},constrainXY:function(){if(this.constrain){var g=Ext.Element.getViewWidth(),b=Ext.Element.getViewHeight(),l=Ext.getDoc().getScroll(),k=this.getXY(),i=k[0],e=k[1],a=this.shadowOffset,j=this.dom.offsetWidth+a,c=this.dom.offsetHeight+a,d=false;if((i+j)>g+l.left){i=g-j-a;d=true}if((e+c)>b+l.top){e=b-c-a;d=true}if(i<l.left){i=l.left;d=true}if(e<l.top){e=l.top;d=true}if(d){Ext.Layer.superclass.setXY.call(this,[i,e]);this.sync()}}return this},getConstrainOffset:function(){return this.shadowOffset},setVisible:function(e,b,d,h,g){var c=this,a;a=function(){if(e){c.sync(true)}if(h){h()}};if(!e){c.hideUnders(true)}c.callParent([e,b,d,h,g]);if(!b){a()}return c},beforeFx:function(){this.beforeAction();return this.callParent(arguments)},afterFx:function(){this.callParent(arguments);this.sync(this.isVisible())},beforeAction:function(){if(!this.updating&&this.shadow){this.shadow.hide()}},setLeft:function(a){this.callParent(arguments);return this.sync()},setTop:function(a){this.callParent(arguments);return this.sync()},setLeftTop:function(b,a){this.callParent(arguments);return this.sync()},setXY:function(d,a,c,g,e){var b=this;g=b.createCB(g);b.fixDisplay();b.beforeAction();b.callParent([d,a,c,g,e]);if(!a){g()}return b},createCB:function(c){var a=this,b=a.shadow&&a.shadow.isVisible();return function(){a.constrainXY();a.sync(b);if(c){c()}}},setX:function(a,b,c,e,d){this.setXY([a,this.getY()],b,c,e,d);return this},setY:function(e,a,b,d,c){this.setXY([this.getX(),e],a,b,d,c);return this},setSize:function(a,c,b,e,i,g){var d=this;i=d.createCB(i);d.beforeAction();d.callParent([a,c,b,e,i,g]);if(!b){i()}return d},setWidth:function(a,b,d,g,e){var c=this;g=c.createCB(g);c.beforeAction();c.callParent([a,b,d,g,e]);if(!b){g()}return c},setHeight:function(b,a,d,g,e){var c=this;g=c.createCB(g);c.beforeAction();c.callParent([b,a,d,g,e]);if(!a){g()}return c},setBounds:function(h,g,a,j,b,c,i,d){var e=this;i=e.createCB(i);e.beforeAction();if(!b){Ext.Layer.superclass.setXY.call(e,[h,g]);Ext.Layer.superclass.setSize.call(e,a,j);i()}else{e.callParent([h,g,a,j,b,c,i,d])}return e},setZIndex:function(a){var b=this;b.zindex=a;if(b.getShim()){b.shim.setStyle("z-index",a++)}if(b.shadow){b.shadow.setZIndex(a++)}return b.setStyle("z-index",a)},onOpacitySet:function(a){var b=this.shadow;if(b){b.setOpacity(a)}}});Ext.define("Ext.util.Bindable",{bindStore:function(a,b){var c=this,d=c.store;if(!b&&c.store){c.onUnbindStore(d,b);if(a!==d&&d.autoDestroy){d.destroyStore()}else{c.unbindStoreListeners(d)}}if(a){a=Ext.data.StoreManager.lookup(a);c.bindStoreListeners(a);c.onBindStore(a,b)}c.store=a||null;return c},getStore:function(){return this.store},unbindStoreListeners:function(a){var b=this.storeListeners;if(b){a.un(b)}},bindStoreListeners:function(a){var c=this,b=Ext.apply({},c.getStoreListeners());if(!b.scope){b.scope=c}c.storeListeners=b;a.on(b)},getStoreListeners:Ext.emptyFn,onUnbindStore:Ext.emptyFn,onBindStore:Ext.emptyFn});Ext.define("Ext.LoadMask",{extend:"Ext.Component",alias:"widget.loadmask",mixins:{floating:"Ext.util.Floating",bindable:"Ext.util.Bindable"},uses:["Ext.data.StoreManager"],msg:"Loading...",msgCls:Ext.baseCSSPrefix+"mask-loading",maskCls:Ext.baseCSSPrefix+"mask",useMsg:true,useTargetEl:false,baseCls:Ext.baseCSSPrefix+"mask-msg",childEls:["msgEl"],renderTpl:'<div id="{id}-msgEl" style="position:relative" class="{[values.$comp.msgCls]}"></div>',floating:{shadow:"frame"},focusOnToFront:false,bringParentToFront:false,constructor:function(a,b){var c=this;if(!a.isComponent){a=Ext.get(a);this.isElement=true}c.ownerCt=a;if(!this.isElement){c.bindComponent(a)}c.callParent([b]);if(c.store){c.bindStore(c.store,true)}},bindComponent:function(a){var c=this,b={scope:this,resize:c.sizeMask,added:c.onComponentAdded,removed:c.onComponentRemoved},d=Ext.container.Container.hierarchyEventSource;if(a.floating){b.move=c.sizeMask;c.activeOwner=a}else{if(a.ownerCt){c.onComponentAdded(a.ownerCt)}else{c.preventBringToFront=true}}c.mon(a,b);c.mon(d,{show:c.onContainerShow,hide:c.onContainerHide,expand:c.onContainerExpand,collapse:c.onContainerCollapse,scope:c})},onComponentAdded:function(a){var b=this;delete b.activeOwner;b.floatParent=a;if(!a.floating){a=a.up("[floating]")}if(a){b.activeOwner=a;b.mon(a,"move",b.sizeMask,b)}a=b.floatParent.ownerCt;if(b.rendered&&b.isVisible()&&a){b.floatOwner=a;b.mon(a,"afterlayout",b.sizeMask,b,{single:true})}},onComponentRemoved:function(a){var c=this,d=c.activeOwner,b=c.floatOwner;if(d){c.mun(d,"move",c.sizeMask,c)}if(b){c.mun(b,"afterlayout",c.sizeMask,c)}delete c.activeOwner;delete c.floatOwner},afterRender:function(){this.callParent(arguments);this.container=this.floatParent.getContentTarget()},onContainerShow:function(a){if(this.isActiveContainer(a)){this.onComponentShow()}},onContainerHide:function(a){if(this.isActiveContainer(a)){this.onComponentHide()}},onContainerExpand:function(a){if(this.isActiveContainer(a)){this.onComponentShow()}},onContainerCollapse:function(a){if(this.isActiveContainer(a)){this.onComponentHide()}},isActiveContainer:function(a){return this.isDescendantOf(a)},onComponentHide:function(){var a=this;if(a.rendered&&a.isVisible()){a.hide();a.showNext=true}},onComponentShow:function(){if(this.showNext){this.show()}delete this.showNext},sizeMask:function(){var a=this,b;if(a.rendered&&a.isVisible()){a.center();b=a.getMaskTarget();a.getMaskEl().show().setSize(b.getSize()).alignTo(b,"tl-tl")}},bindStore:function(a,b){var c=this;c.mixins.bindable.bindStore.apply(c,arguments);a=c.store;if(a&&a.isLoading()){c.onBeforeLoad()}},getStoreListeners:function(){return{beforeload:this.onBeforeLoad,load:this.onLoad,exception:this.onLoad,cachemiss:this.onBeforeLoad,cachefilled:this.onLoad}},onDisable:function(){this.callParent(arguments);if(this.loading){this.onLoad()}},getOwner:function(){return this.ownerCt||this.floatParent},getMaskTarget:function(){var a=this.getOwner();return this.useTargetEl?a.getTargetEl():a.getEl()},onBeforeLoad:function(){var c=this,a=c.getOwner(),b;if(!c.disabled){c.loading=true;if(a.componentLayoutCounter){c.maybeShow()}else{b=a.afterComponentLayout;a.afterComponentLayout=function(){a.afterComponentLayout=b;b.apply(a,arguments);c.maybeShow()}}}},maybeShow:function(){var b=this,a=b.getOwner();if(!a.isVisible(true)){b.showNext=true}else{if(b.loading&&a.rendered){b.show()}}},getMaskEl:function(){var a=this;return a.maskEl||(a.maskEl=a.el.insertSibling({cls:a.maskCls,style:{zIndex:a.el.getStyle("zIndex")-2}},"before"))},onShow:function(){var b=this,a=b.msgEl;b.callParent(arguments);b.loading=true;if(b.useMsg){a.show().update(b.msg)}else{a.parent().hide()}},hide:function(){if(this.isElement){this.ownerCt.unmask();this.fireEvent("hide",this);return}delete this.showNext;return this.callParent(arguments)},onHide:function(){this.callParent();this.getMaskEl().hide()},show:function(){if(this.isElement){this.ownerCt.mask(this.useMsg?this.msg:"",this.msgCls);this.fireEvent("show",this);return}return this.callParent(arguments)},afterShow:function(){this.callParent(arguments);this.sizeMask()},setZIndex:function(b){var c=this,a=c.activeOwner;if(a){b=parseInt(a.el.getStyle("zIndex"),10)+1}c.getMaskEl().setStyle("zIndex",b-1);return c.mixins.floating.setZIndex.apply(c,arguments)},onLoad:function(){this.loading=false;this.hide()},onDestroy:function(){var a=this;if(a.isElement){a.ownerCt.unmask()}Ext.destroy(a.maskEl);a.callParent()}});Ext.define("Ext.data.association.Association",{alternateClassName:"Ext.data.Association",primaryKey:"id",defaultReaderType:"json",isAssociation:true,initialConfig:null,statics:{AUTO_ID:1000,create:function(a){if(Ext.isString(a)){a={type:a}}switch(a.type){case"belongsTo":return new Ext.data.association.BelongsTo(a);case"hasMany":return new Ext.data.association.HasMany(a);case"hasOne":return new Ext.data.association.HasOne(a);default:}return a}},constructor:function(a){Ext.apply(this,a);var d=this,b=Ext.ModelManager.types,c=a.ownerModel,g=a.associatedModel,e=b[c],h=b[g];d.initialConfig=a;d.ownerModel=e;d.associatedModel=h;Ext.applyIf(d,{ownerName:c,associatedName:g});d.associationId="association"+(++d.statics().AUTO_ID)},getReader:function(){var c=this,a=c.reader,b=c.associatedModel;if(a){if(Ext.isString(a)){a={type:a}}if(a.isReader){a.setModel(b)}else{Ext.applyIf(a,{model:b,type:c.defaultReaderType})}c.reader=Ext.createByAlias("reader."+a.type,a)}return c.reader||null}});Ext.define("Ext.ModelManager",{extend:"Ext.AbstractManager",alternateClassName:"Ext.ModelMgr",requires:["Ext.data.association.Association"],singleton:true,typeName:"mtype",associationStack:[],registerType:function(c,b){var d=b.prototype,a;if(d&&d.isModel){a=b}else{if(!b.extend){b.extend="Ext.data.Model"}a=Ext.define(c,b)}this.types[c]=a;return a},onModelDefined:function(c){var a=this.associationStack,g=a.length,e=[],b,d,h;for(d=0;d<g;d++){b=a[d];if(b.associatedModel==c.modelName){e.push(b)}}for(d=0,g=e.length;d<g;d++){h=e[d];this.types[h.ownerModel].prototype.associations.add(Ext.data.association.Association.create(h));Ext.Array.remove(a,h)}},registerDeferredAssociation:function(a){this.associationStack.push(a)},getModel:function(b){var a=b;if(typeof a=="string"){a=this.types[a]}return a},create:function(b,a,d){var c=typeof a=="function"?a:this.types[a||b.name];return new c(b,d)}},function(){Ext.regModel=function(){return this.ModelManager.registerType.apply(this.ModelManager,arguments)}});Ext.define("Ext.PluginManager",{extend:"Ext.AbstractManager",alternateClassName:"Ext.PluginMgr",singleton:true,typeName:"ptype",create:function(a,b){if(a.init){return a}else{return Ext.createByAlias("plugin."+(a.ptype||b),a)}},findByType:function(c,g){var e=[],b=this.types,a,d;for(a in b){if(!b.hasOwnProperty(a)){continue}d=b[a];if(d.type==c&&(!g||(g===true&&d.isDefault))){e.push(d)}}return e}},function(){Ext.preg=function(){return Ext.PluginManager.registerType.apply(Ext.PluginManager,arguments)}});Ext.define("Ext.layout.component.ProgressBar",{alias:["layout.progressbar"],extend:"Ext.layout.component.Auto",type:"progressbar",beginLayout:function(d){var b=this,a,c;b.callParent(arguments);if(!d.textEls){c=b.owner.textEl;if(c.isComposite){d.textEls=[];c=c.elements;for(a=c.length;a--;){d.textEls[a]=d.getEl(Ext.get(c[a]))}}else{d.textEls=[d.getEl("textEl")]}}},calculate:function(e){var c=this,a,d,b;c.callParent(arguments);if(Ext.isNumber(b=e.getProp("width"))){b-=e.getBorderInfo().width;d=e.textEls;for(a=d.length;a--;){d[a].setWidth(b)}}else{c.done=false}}});Ext.define("Ext.dom.CompositeElement",{alternateClassName:"Ext.CompositeElement",extend:"Ext.dom.CompositeElementLite",getElement:function(a){return a},transformElement:function(a){return Ext.get(a)}},function(){Ext.dom.Element.select=function(a,d,b){var c;if(typeof a=="string"){c=Ext.dom.Element.selectorFunction(a,b)}else{if(a.length!==undefined){c=a}else{}}return(d===true)?new Ext.CompositeElement(c):new Ext.CompositeElementLite(c)}});Ext.select=Ext.Element.select;Ext.define("Ext.ProgressBar",{extend:"Ext.Component",alias:"widget.progressbar",requires:["Ext.Template","Ext.CompositeElement","Ext.TaskManager","Ext.layout.component.ProgressBar"],uses:["Ext.fx.Anim"],baseCls:Ext.baseCSSPrefix+"progress",animate:false,text:"",waitTimer:null,childEls:["bar"],renderTpl:['<tpl if="internalText">','<div class="{baseCls}-text {baseCls}-text-back">{text}</div>',"</tpl>",'<div id="{id}-bar" class="{baseCls}-bar" style="width:{percentage}%">','<tpl if="internalText">','<div class="{baseCls}-text">',"<div>{text}</div>","</div>","</tpl>","</div>"],componentLayout:"progressbar",initComponent:function(){this.callParent();this.addEvents("update")},initRenderData:function(){var a=this;return Ext.apply(a.callParent(),{internalText:!a.hasOwnProperty("textEl"),text:a.text||"&#160;",percentage:a.value?a.value*100:0})},onRender:function(){var a=this;a.callParent(arguments);if(a.textEl){a.textEl=Ext.get(a.textEl);a.updateText(a.text)}else{a.textEl=a.el.select("."+a.baseCls+"-text")}},updateProgress:function(d,e,a){var c=this,b=c.value;c.value=d||0;if(e){c.updateText(e)}if(c.rendered&&!c.isDestroyed){if(a===true||(a!==false&&c.animate)){c.bar.stopAnimation();c.bar.animate(Ext.apply({from:{width:(b*100)+"%"},to:{width:(c.value*100)+"%"}},c.animate))}else{c.bar.setStyle("width",(c.value*100)+"%")}}c.fireEvent("update",c,c.value,e);return c},updateText:function(b){var a=this;a.text=b;if(a.rendered){a.textEl.update(a.text)}return a},applyText:function(a){this.updateText(a)},getText:function(){return this.text},wait:function(c){var b=this,a;if(!b.waitTimer){a=b;c=c||{};b.updateText(c.text);b.waitTimer=Ext.TaskManager.start({run:function(d){var e=c.increment||10;d-=1;b.updateProgress(((((d+e)%e)+1)*(100/e))*0.01,null,c.animate)},interval:c.interval||1000,duration:c.duration,onStop:function(){if(c.fn){c.fn.apply(c.scope||b)}b.reset()},scope:a})}return b},isWaiting:function(){return this.waitTimer!==null},reset:function(a){var b=this;b.updateProgress(0);b.clearTimer();if(a===true){b.hide()}return b},clearTimer:function(){var a=this;if(a.waitTimer){a.waitTimer.onStop=null;Ext.TaskManager.stop(a.waitTimer);a.waitTimer=null}},onDestroy:function(){var a=this;a.clearTimer();if(a.rendered){if(a.textEl.isComposite){a.textEl.clear()}Ext.destroyMembers(a,"textEl","progressBar")}a.callParent()}});Ext.define("Ext.ShadowPool",{singleton:true,requires:["Ext.DomHelper"],markup:(function(){return Ext.String.format('<div class="{0}{1}-shadow" role="presentation"></div>',Ext.baseCSSPrefix,Ext.isIE&&!Ext.supports.CSS3BoxShadow?"ie":"css")}()),shadows:[],pull:function(){var a=this.shadows.shift();if(!a){a=Ext.get(Ext.DomHelper.insertHtml("beforeBegin",document.body.firstChild,this.markup));a.autoBoxAdjust=false}return a},push:function(a){this.shadows.push(a)},reset:function(){var c=[].concat(this.shadows),b,a=c.length;for(b=0;b<a;b++){c[b].remove()}this.shadows=[]}});Ext.define("Ext.Shadow",{requires:["Ext.ShadowPool"],constructor:function(b){var c=this,d,e,a;Ext.apply(c,b);if(!Ext.isString(c.mode)){c.mode=c.defaultMode}e=c.offset;a=Math.floor(e/2);c.opacity=50;switch(c.mode.toLowerCase()){case"drop":if(Ext.supports.CSS3BoxShadow){d={t:e,l:e,h:-e,w:-e}}else{d={t:-a,l:-a,h:-a,w:-a}}break;case"sides":if(Ext.supports.CSS3BoxShadow){d={t:e,l:0,h:-e,w:0}}else{d={t:-(1+a),l:1+a-2*e,h:-1,w:a-1}}break;case"frame":if(Ext.supports.CSS3BoxShadow){d={t:0,l:0,h:0,w:0}}else{d={t:1+a-2*e,l:1+a-2*e,h:e-a-1,w:e-a-1}}break}c.adjusts=d},getShadowSize:function(){var b=this,d=b.el?b.offset:0,a=[d,d,d,d],c=b.mode.toLowerCase();if(b.el&&c!=="frame"){a[0]=0;if(c=="drop"){a[3]=0}}return a},offset:4,defaultMode:"drop",boxShadowProperty:(function(){var b="boxShadow",a=document.documentElement.style;if(!("boxShadow" in a)){if("WebkitBoxShadow" in a){b="WebkitBoxShadow"}else{if("MozBoxShadow" in a){b="MozBoxShadow"}}}return b}()),show:function(c){var b=this,a;c=Ext.get(c);if(!b.el){b.el=Ext.ShadowPool.pull();if(b.el.dom.nextSibling!=c.dom){b.el.insertBefore(c)}}a=(parseInt(c.getStyle("z-index"),10)-1)||0;b.el.setStyle("z-index",b.zIndex||a);if(Ext.isIE&&!Ext.supports.CSS3BoxShadow){b.el.dom.style.filter="progid:DXImageTransform.Microsoft.alpha(opacity="+b.opacity+") progid:DXImageTransform.Microsoft.Blur(pixelradius="+(b.offset)+")"}b.realign(c.getLocalX(),c.getLocalY(),c.dom.offsetWidth,c.dom.offsetHeight);b.el.dom.style.display="block"},isVisible:function(){return this.el?true:false},realign:function(b,n,k,g){if(!this.el){return}var a=this.adjusts,i=this.el.dom,j=i.style,c,e,h,m;j.left=(b+a.l)+"px";j.top=(n+a.t)+"px";c=Math.max(k+a.w,0);e=Math.max(g+a.h,0);h=c+"px";m=e+"px";if(j.width!=h||j.height!=m){j.width=h;j.height=m;if(Ext.supports.CSS3BoxShadow){j[this.boxShadowProperty]="0 0 "+this.offset+"px #888"}}},hide:function(){var a=this;if(a.el){a.el.dom.style.display="none";Ext.ShadowPool.push(a.el);delete a.el}},setZIndex:function(a){this.zIndex=a;if(this.el){this.el.setStyle("z-index",a)}},setOpacity:function(a){if(this.el){if(Ext.isIE&&!Ext.supports.CSS3BoxShadow){a=Math.floor(a*100/2)/100}this.opacity=a;this.el.setOpacity(a)}}});Ext.define("Ext.app.Controller",{mixins:{observable:"Ext.util.Observable"},onClassExtended:function(j,c,i){var h=Ext.getClassName(j),d=h.match(/^(.*)\.controller\./),b,g,k,a,e;if(d!==null){b=Ext.Loader.getPrefix(h)||d[1];g=i.onBeforeCreated;k=[];a=["model","view","store"];i.onBeforeCreated=function(t,n){var o,q,l,r,m,p,s;for(o=0,q=a.length;o<q;o++){l=a[o];e=b+"."+l+".";r=Ext.Array.from(n[l+"s"]);for(m=0,p=r.length;m<p;m++){s=r[m];if(s.indexOf(".")!==-1&&(Ext.ClassManager.isCreated(s)||Ext.Loader.isAClassNameWithAKnownPrefix(s))){k.push(s)}else{k.push(e+s)}}}Ext.require(k,Ext.Function.pass(g,arguments,this))}}},constructor:function(a){this.mixins.observable.constructor.call(this,a);Ext.apply(this,a||{});this.createGetters("model",this.models);this.createGetters("store",this.stores);this.createGetters("view",this.views);if(this.refs){this.ref(this.refs)}},init:Ext.emptyFn,onLaunch:Ext.emptyFn,createGetters:function(g,j){g=Ext.String.capitalize(g);var e=0,a=(j)?j.length:0,h,b,c,k,d;for(;e<a;e++){h="get";b=j[e];c=b.split(".");d=c.length;for(k=0;k<d;k++){h+=Ext.String.capitalize(c[k])}h+=g;if(!this[h]){this[h]=Ext.Function.pass(this["get"+g],[b],this)}this[h](b)}},ref:function(a){a=Ext.Array.from(a);var g=this,b=0,e=a.length,h,d,c;g.references=g.references||[];for(;b<e;b++){h=a[b];d=h.ref;c="get"+Ext.String.capitalize(d);if(!g[c]){g[c]=Ext.Function.pass(g.getRef,[d,h],g)}g.references.push(d.toLowerCase())}},addRef:function(a){return this.ref([a])},getRef:function(d,e,a){this.refCache=this.refCache||{};e=e||{};a=a||{};Ext.apply(e,a);if(e.forceCreate){return Ext.ComponentManager.create(e,"component")}var c=this,b=c.refCache[d];if(!b){c.refCache[d]=b=Ext.ComponentQuery.query(e.selector)[0];if(!b&&e.autoCreate){c.refCache[d]=b=Ext.ComponentManager.create(e,"component")}if(b){b.on("beforedestroy",function(){c.refCache[d]=null})}}return b},hasRef:function(a){return this.references&&this.references.indexOf(a.toLowerCase())!==-1},control:function(a,b){this.application.control(a,b,this)},getController:function(a){return this.application.getController(a)},getStore:function(a){return this.application.getStore(a)},getModel:function(a){return this.application.getModel(a)},getView:function(a){return this.application.getView(a)}});Ext.define("Ext.data.IdGenerator",{isGenerator:true,constructor:function(a){var b=this;Ext.apply(b,a);if(b.id){Ext.data.IdGenerator.all[b.id]=b}},getRecId:function(a){return a.modelName+"-"+a.internalId},statics:{all:{},get:function(a){var c,d,b;if(typeof a=="string"){d=b=a;a=null}else{if(a.isGenerator){return a}else{d=a.id||a.type;b=a.type}}c=this.all[d];if(!c){c=Ext.create("idgen."+b,a)}return c}}});Ext.define("Ext.data.SortTypes",{singleton:true,none:function(a){return a},stripTagsRE:/<\/?[^>]+>/gi,asText:function(a){return String(a).replace(this.stripTagsRE,"")},asUCText:function(a){return String(a).toUpperCase().replace(this.stripTagsRE,"")},asUCString:function(a){return String(a).toUpperCase()},asDate:function(a){if(!a){return 0}if(Ext.isDate(a)){return a.getTime()}return Date.parse(String(a))},asFloat:function(a){var b=parseFloat(String(a).replace(/,/g,""));return isNaN(b)?0:b},asInt:function(a){var b=parseInt(String(a).replace(/,/g,""),10);return isNaN(b)?0:b}});Ext.define("Ext.data.Types",{singleton:true,requires:["Ext.data.SortTypes"]},function(){var a=Ext.data.SortTypes;Ext.apply(Ext.data.Types,{stripRe:/[\$,%]/g,AUTO:{sortType:a.none,type:"auto"},STRING:{convert:function(c){var b=this.useNull?null:"";return(c===undefined||c===null)?b:String(c)},sortType:a.asUCString,type:"string"},INT:{convert:function(b){return b!==undefined&&b!==null&&b!==""?parseInt(String(b).replace(Ext.data.Types.stripRe,""),10):(this.useNull?null:0)},sortType:a.none,type:"int"},FLOAT:{convert:function(b){return b!==undefined&&b!==null&&b!==""?parseFloat(String(b).replace(Ext.data.Types.stripRe,""),10):(this.useNull?null:0)},sortType:a.none,type:"float"},BOOL:{convert:function(b){if(this.useNull&&(b===undefined||b===null||b==="")){return null}return b===true||b==="true"||b==1},sortType:a.none,type:"bool"},DATE:{convert:function(c){var d=this.dateFormat,b;if(!c){return null}if(Ext.isDate(c)){return c}if(d){if(d=="timestamp"){return new Date(c*1000)}if(d=="time"){return new Date(parseInt(c,10))}return Ext.Date.parse(c,d)}b=Date.parse(c);return b?new Date(b):null},sortType:a.asDate,type:"date"}});Ext.apply(Ext.data.Types,{BOOLEAN:this.BOOL,INTEGER:this.INT,NUMBER:this.FLOAT})});Ext.define("Ext.data.Field",{requires:["Ext.data.Types","Ext.data.SortTypes"],alias:"data.field",isField:true,constructor:function(b){var d=this,c=Ext.data.Types,a;if(Ext.isString(b)){b={name:b}}Ext.apply(d,b);a=d.sortType;if(d.type){if(Ext.isString(d.type)){d.type=c[d.type.toUpperCase()]||c.AUTO}}else{d.type=c.AUTO}if(Ext.isString(a)){d.sortType=Ext.data.SortTypes[a]}else{if(Ext.isEmpty(a)){d.sortType=d.type.sortType}}if(!b.hasOwnProperty("convert")){d.convert=d.type.convert}else{if(!d.convert&&d.type.convert&&!b.hasOwnProperty("defaultValue")){d.defaultValue=d.type.convert(d.defaultValue)}}if(b.convert){d.hasCustomConvert=true}},dateFormat:null,useNull:false,defaultValue:"",mapping:null,sortType:null,sortDir:"ASC",allowBlank:true,persist:true});Ext.define("Ext.data.Errors",{extend:"Ext.util.MixedCollection",isValid:function(){return this.length===0},getByField:function(e){var d=[],a,c,b;for(b=0;b<this.length;b++){a=this.items[b];if(a.field==e){d.push(a)}}return d}});Ext.define("Ext.data.Operation",{synchronous:true,action:undefined,filters:undefined,sorters:undefined,groupers:undefined,start:undefined,limit:undefined,batch:undefined,callback:undefined,scope:undefined,started:false,running:false,complete:false,success:undefined,exception:false,error:undefined,actionCommitRecordsRe:/^(?:create|update)$/i,actionSkipSyncRe:/^destroy$/i,constructor:function(a){Ext.apply(this,a||{})},commitRecords:function(k){var h=this,j,g,a,c,b,d,e;if(!h.actionSkipSyncRe.test(h.action)){a=h.records;if(a&&a.length){if(a.length>1){if(h.action=="update"||a[0].clientIdProperty){j=new Ext.util.MixedCollection();j.addAll(k);for(g=a.length;g--;){b=a[g];c=j.findBy(h.matchClientRec,b);b.copyFrom(c)}}else{for(d=0,e=a.length;d<e;++d){b=a[d];c=k[d];if(b&&c){h.updateRecord(b,c)}}}}else{this.updateRecord(a[0],k[0])}if(h.actionCommitRecordsRe.test(h.action)){for(g=a.length;g--;){a[g].commit()}}}}},updateRecord:function(a,b){if(b&&(a.phantom||a.getId()===b.getId())){a.copyFrom(b)}},matchClientRec:function(c){var a=this,b=a.getId();if(b&&c.getId()===b){return true}return c.internalId===a.internalId},setStarted:function(){this.started=true;this.running=true},setCompleted:function(){this.complete=true;this.running=false},setSuccessful:function(){this.success=true},setException:function(a){this.exception=true;this.success=false;this.running=false;this.error=a},hasException:function(){return this.exception===true},getError:function(){return this.error},getRecords:function(){var a=this.getResultSet();return this.records||(a?a.records:null)},getResultSet:function(){return this.resultSet},isStarted:function(){return this.started===true},isRunning:function(){return this.running===true},isComplete:function(){return this.complete===true},wasSuccessful:function(){return this.isComplete()&&this.success===true},setBatch:function(a){this.batch=a},allowWrite:function(){return this.action!="read"}});Ext.define("Ext.data.validations",{singleton:true,presenceMessage:"must be present",lengthMessage:"is the wrong length",formatMessage:"is the wrong format",inclusionMessage:"is not included in the list of acceptable values",exclusionMessage:"is not an acceptable value",emailMessage:"is not a valid email address",emailRe:/^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/,presence:function(a,b){if(arguments.length===1){b=a}return !!b||b===0},length:function(b,e){if(e===undefined||e===null){return false}var d=e.length,c=b.min,a=b.max;if((c&&d<c)||(a&&d>a)){return false}else{return true}},email:function(b,a){return Ext.data.validations.emailRe.test(a)},format:function(a,b){return !!(a.matcher&&a.matcher.test(b))},inclusion:function(a,b){return a.list&&Ext.Array.indexOf(a.list,b)!=-1},exclusion:function(a,b){return a.list&&Ext.Array.indexOf(a.list,b)==-1}});Ext.define("Ext.data.Model",{alternateClassName:"Ext.data.Record",mixins:{observable:"Ext.util.Observable"},requires:["Ext.ModelManager","Ext.data.IdGenerator","Ext.data.Field","Ext.data.Errors","Ext.data.Operation","Ext.data.validations","Ext.util.MixedCollection"],compareConvertFields:function(a,d){var c=a.convert&&a.type&&a.convert!==a.type.convert,b=d.convert&&d.type&&d.convert!==d.type.convert;if(c&&!b){return 1}if(!c&&b){return -1}return 0},itemNameFn:function(a){return a.name},onClassExtended:function(b,c,a){var d=a.onBeforeCreated;a.onBeforeCreated=function(g,D){var C=this,E=Ext.getClassName(g),r=g.prototype,x=g.prototype.superclass,j=D.validations||[],t=D.fields||[],h,m=D.associations||[],e=function(G,I){var H=0,F,J;if(G){G=Ext.Array.from(G);for(F=G.length;H<F;++H){J=G[H];if(!Ext.isObject(J)){J={model:J}}J.type=I;m.push(J)}}},u=D.idgen,A=new Ext.util.MixedCollection(false,r.itemNameFn),y=new Ext.util.MixedCollection(false,r.itemNameFn),q=x.validations,B=x.fields,l=x.associations,z,w,o,p=[],n=D.idProperty||g.prototype.idProperty,v=function(G,F,i){var H,I;if(A.events.add.firing){I=G;H=F}else{H=i;I=F.originalIndex}H.originalIndex=I;if(H.mapping===n||(H.mapping==null&&H.name===n)){H.defaultValue=undefined}},s=D.proxy||g.prototype.proxy||g.prototype.defaultProxyType,k=function(){A.sortBy(r.compareConvertFields)};g.modelName=E;r.modelName=E;if(q){j=q.concat(j)}D.validations=j;if(B){t=B.items.concat(t)}A.on({add:v,replace:v});for(w=0,o=t.length;w<o;++w){h=t[w];A.add(h.isField?h:new Ext.data.Field(h))}if(!A.get(n)){A.add(new Ext.data.Field(n))}k();A.on({add:k,replace:k});D.fields=A;if(u){D.idgen=Ext.data.IdGenerator.get(u)}e(D.belongsTo,"belongsTo");delete D.belongsTo;e(D.hasMany,"hasMany");delete D.hasMany;e(D.hasOne,"hasOne");delete D.hasOne;if(l){m=l.items.concat(m)}for(w=0,o=m.length;w<o;++w){p.push("association."+m[w].type.toLowerCase())}if(s&&!s.isProxy){p.push("proxy."+(typeof s==="string"?s:s.type))}Ext.require(p,function(){Ext.ModelManager.registerType(E,g);for(w=0,o=m.length;w<o;++w){z=m[w];if(z.isAssociation){z=Ext.applyIf({ownerModel:E,associatedModel:z.model},z.initialConfig)}else{Ext.apply(z,{ownerModel:E,associatedModel:z.model})}if(Ext.ModelManager.getModel(z.model)===undefined){Ext.ModelManager.registerDeferredAssociation(z)}else{y.add(Ext.data.association.Association.create(z))}}D.associations=y;d.call(C,g,D,a);g.setProxy(s);Ext.ModelManager.onModelDefined(g)})}},inheritableStatics:{setProxy:function(a){if(!a.isProxy){if(typeof a=="string"){a={type:a}}a=Ext.createByAlias("proxy."+a.type,a)}a.setModel(this);this.proxy=this.prototype.proxy=a;return a},getProxy:function(){return this.proxy},setFields:function(c,d,b){var j=this,h=j.prototype,g=h.fields,a=c?c.length:0,e=0;if(d){h.idProperty=d}if(b){h.clientIdProperty=b}if(g){g.clear()}else{g=j.prototype.fields=new Ext.util.MixedCollection(false,function(i){return i.name})}for(;e<a;e++){g.add(new Ext.data.Field(c[e]))}if(!g.get(h.idProperty)){g.add(new Ext.data.Field(h.idProperty))}j.fields=g;return g},getFields:function(){return this.prototype.fields.items},load:function(g,c){c=Ext.apply({},c);c=Ext.applyIf(c,{action:"read",id:g});var b=new Ext.data.Operation(c),d=c.scope||this,a=null,e;e=function(h){if(h.wasSuccessful()){a=h.getRecords()[0];Ext.callback(c.success,d,[a,h])}else{Ext.callback(c.failure,d,[a,h])}Ext.callback(c.callback,d,[a,h])};this.proxy.read(b,e,this)}},statics:{PREFIX:"ext-record",AUTO_ID:1,EDIT:"edit",REJECT:"reject",COMMIT:"commit",id:function(a){var b=[this.PREFIX,"-",this.AUTO_ID++].join("");a.phantom=true;a.internalId=b;return b}},idgen:{isGenerator:true,type:"default",generate:function(){return null},getRecId:function(a){return a.modelName+"-"+a.internalId}},editing:false,dirty:false,persistenceProperty:"data",evented:false,isModel:true,phantom:false,idProperty:"id",clientIdProperty:null,defaultProxyType:"ajax",constructor:function(j,d,o,b){j=j||{};var l=this,k,e,m,a,n,g,c,h;l.internalId=(d||d===0)?d:Ext.data.Model.id(l);l.raw=o||j;if(!l.data){l.data={}}l.modified={};if(l.persistanceProperty){l.persistenceProperty=l.persistanceProperty}l[l.persistenceProperty]=b||{};l.mixins.observable.constructor.call(l);if(!b){k=l.fields.items;e=k.length;h=0;c=l[l.persistenceProperty];if(Ext.isArray(j)){for(;h<e;h++){m=k[h];a=m.name;n=j[m.originalIndex];if(n===undefined){n=m.defaultValue}if(m.convert){n=m.convert(n,l)}if(n!==undefined){c[a]=n}}}else{for(;h<e;h++){m=k[h];a=m.name;n=j[a];if(n===undefined){n=m.defaultValue}if(m.convert){n=m.convert(n,l)}if(n!==undefined){c[a]=n}}}}l.stores=[];if(l.getId()){l.phantom=false}else{if(l.phantom){g=l.idgen.generate();if(g!==null){l.setId(g)}}}l.dirty=false;l.modified={};if(typeof l.init=="function"){l.init()}l.id=l.idgen.getRecId(l)},get:function(a){return this[this.persistenceProperty][a]},_singleProp:{},set:function(r,b){var j=this,h=j[j.persistenceProperty],i=j.fields,q=j.modified,o=(typeof r=="string"),p,k,g,n,e,a,c,d,l,m;if(o){m=j._singleProp;m[r]=b}else{m=r}for(a in m){if(m.hasOwnProperty(a)){l=m[a];if(i&&(k=i.get(a))&&k.convert){l=k.convert(l,j)}p=h[a];if(j.isEqual(p,l)){continue}h[a]=l;(e||(e=[])).push(a);if(k&&k.persist){if(q.hasOwnProperty(a)){if(j.isEqual(q[a],l)){delete q[a];j.dirty=false;for(n in q){if(q.hasOwnProperty(n)){j.dirty=true;break}}}}else{j.dirty=true;q[a]=p}}if(a==j.idProperty){g=true;c=p;d=l}}}if(o){delete m[r]}if(g){j.fireEvent("idchanged",j,c,d)}if(!j.editing&&e){j.afterEdit(e)}return e||null},copyFrom:function(g){if(g){var e=this,c=e.fields.items,k=c.length,h,a=0,d=e[e.persistenceProperty],b=g[g.persistenceProperty],j;for(;a<k;a++){h=c[a];j=b[h.name];if(j!==undefined){d[h.name]=j}}if(e.phantom&&!g.phantom){e.setId(g.getId())}}},isEqual:function(d,c){if(Ext.isDate(d)&&Ext.isDate(c)){return Ext.Date.isEqual(d,c)}return d===c},beginEdit:function(){var a=this;if(!a.editing){a.editing=true;a.dirtySave=a.dirty;a.dataSave=Ext.apply({},a[a.persistenceProperty]);a.modifiedSave=Ext.apply({},a.modified)}},cancelEdit:function(){var a=this;if(a.editing){a.editing=false;a.modified=a.modifiedSave;a[a.persistenceProperty]=a.dataSave;a.dirty=a.dirtySave;delete a.modifiedSave;delete a.dataSave;delete a.dirtySave}},endEdit:function(a,c){var b=this,d;if(b.editing){b.editing=false;if(!c){c=b.getModifiedFieldNames()}d=b.dirty||c.length>0;delete b.modifiedSave;delete b.dataSave;delete b.dirtySave;if(d&&a!==true){b.afterEdit(c)}}},getModifiedFieldNames:function(){var d=this,c=d.dataSave,e=d[d.persistenceProperty],a=[],b;for(b in e){if(e.hasOwnProperty(b)){if(!d.isEqual(e[b],c[b])){a.push(b)}}}return a},getChanges:function(){var a=this.modified,b={},c;for(c in a){if(a.hasOwnProperty(c)){b[c]=this.get(c)}}return b},isModified:function(a){return this.modified.hasOwnProperty(a)},setDirty:function(){var c=this,a=c.fields.items,g=a.length,e,b,d;c.dirty=true;for(d=0;d<g;d++){e=a[d];if(e.persist){b=e.name;c.modified[b]=c.get(b)}}},reject:function(a){var c=this,b=c.modified,d;for(d in b){if(b.hasOwnProperty(d)){if(typeof b[d]!="function"){c[c.persistenceProperty][d]=b[d]}}}c.dirty=false;c.editing=false;c.modified={};if(a!==true){c.afterReject()}},commit:function(a){var b=this;b.phantom=b.dirty=b.editing=false;b.modified={};if(a!==true){b.afterCommit()}},copy:function(a){var b=this;return new b.self(b.raw,a,null,Ext.apply({},b[b.persistenceProperty]))},setProxy:function(a){if(!a.isProxy){if(typeof a==="string"){a={type:a}}a=Ext.createByAlias("proxy."+a.type,a)}a.setModel(this.self);this.proxy=a;return a},getProxy:function(){return this.proxy},validate:function(){var k=new Ext.data.Errors(),c=this.validations,e=Ext.data.validations,b,d,j,a,h,g;if(c){b=c.length;for(g=0;g<b;g++){d=c[g];j=d.field||d.name;h=d.type;a=e[h](d,this.get(j));if(!a){k.add({field:j,message:d.message||e[h+"Message"]})}}}return k},isValid:function(){return this.validate().isValid()},save:function(m){m=Ext.apply({},m);var g=this,b=g.phantom?"create":"update",l=m.scope||g,j=g.stores,c=0,e,h,d,a,k;Ext.apply(m,{records:[g],action:b});a=new Ext.data.Operation(m);k=function(i){d=[g,i];if(i.wasSuccessful()){for(e=j.length;c<e;c++){h=j[c];h.fireEvent("write",h,i);h.fireEvent("datachanged",h)}Ext.callback(m.success,l,d)}else{Ext.callback(m.failure,l,d)}Ext.callback(m.callback,l,d)};g.getProxy()[b](a,k,g);return g},destroy:function(l){l=Ext.apply({},l);var e=this,k=l.scope||e,h=e.stores,b=0,d,g,c,a,j;Ext.apply(l,{records:[e],action:"destroy"});a=new Ext.data.Operation(l);j=function(i){c=[e,i];if(i.wasSuccessful()){for(d=h.length;b<d;b++){g=h[b];g.fireEvent("write",g,i);g.fireEvent("datachanged",g)}e.clearListeners();Ext.callback(l.success,k,c)}else{Ext.callback(l.failure,k,c)}Ext.callback(l.callback,k,c)};e.getProxy().destroy(a,j,e);return e},getId:function(){return this.get(this.idProperty)},getObservableId:function(){return this.id},setId:function(a){this.set(this.idProperty,a);this.phantom=!(a||a===0)},join:function(a){Ext.Array.include(this.stores,a);this.store=this.stores[0]},unjoin:function(a){Ext.Array.remove(this.stores,a);this.store=this.stores[0]||null},afterEdit:function(a){this.callStore("afterEdit",a)},afterReject:function(){this.callStore("afterReject")},afterCommit:function(){this.callStore("afterCommit")},callStore:function(g){var d=Ext.Array.clone(arguments),b=this.stores,e=0,a=b.length,c,h;d[0]=this;for(;e<a;++e){c=b[e];if(c&&typeof c[g]=="function"){c[g].apply(c,d)}h=c.treeStore;if(h&&typeof h[g]=="function"){h[g].apply(h,d)}}},getData:function(c){var d=this,a=d.fields.items,h=a.length,g={},b,e;for(e=0;e<h;e++){b=a[e].name;g[b]=d.get(b)}if(c===true){Ext.apply(g,d.getAssociatedData())}return g},getAssociatedData:function(){return this.prepareAssociatedData({},1)},prepareAssociatedData:function(w,z){var y=this,t=y.associations.items,e=t.length,x={},q=[],v=[],m=[],p,b,a,n,g,l,k,u,h,c,s,r,d,A;for(s=0;s<e;s++){c=t[s];u=c.associationId;k=w[u];if(k&&k!==z){continue}w[u]=z;d=c.type;A=c.name;if(d=="hasMany"){p=y[c.storeName];x[A]=[];if(p&&p.getCount()>0){b=p.data.items;h=b.length;for(r=0;r<h;r++){a=b[r];x[A][r]=a.getData();q.push(a);v.push(A);m.push(r)}}}else{if(d=="belongsTo"||d=="hasOne"){a=y[c.instanceName];if(a!==undefined){x[A]=a.getData();q.push(a);v.push(A);m.push(-1)}}}}for(s=0,h=q.length;s<h;++s){a=q[s];n=x[v[s]];g=m[s];l=a.prepareAssociatedData(w,z+1);if(g===-1){Ext.apply(n,l)}else{Ext.apply(n[g],l)}}return x}});Ext.define("Ext.data.StoreManager",{extend:"Ext.util.MixedCollection",alternateClassName:["Ext.StoreMgr","Ext.data.StoreMgr","Ext.StoreManager"],singleton:true,uses:["Ext.data.ArrayStore"],register:function(){for(var a=0,b;(b=arguments[a]);a++){this.add(b)}},unregister:function(){for(var a=0,b;(b=arguments[a]);a++){this.remove(this.lookup(b))}},lookup:function(c){if(Ext.isArray(c)){var b=["field1"],e=!Ext.isArray(c[0]),g=c,d,a;if(e){g=[];for(d=0,a=c.length;d<a;++d){g.push([c[d]])}}else{for(d=2,a=c[0].length;d<=a;++d){b.push("field"+d)}}return new Ext.data.ArrayStore({data:g,fields:b,autoDestroy:true,autoCreated:true,expanded:e})}if(Ext.isString(c)){return this.get(c)}else{return Ext.data.AbstractStore.create(c)}},getKey:function(a){return a.storeId}},function(){Ext.regStore=function(c,b){var a;if(Ext.isObject(c)){b=c}else{b.storeId=c}if(b instanceof Ext.data.Store){a=b}else{a=new Ext.data.Store(b)}return Ext.data.StoreManager.register(a)};Ext.getStore=function(a){return Ext.data.StoreManager.lookup(a)}});Ext.define("Ext.layout.component.Dock",{extend:"Ext.layout.component.Component",alias:"layout.dock",alternateClassName:"Ext.layout.component.AbstractDock",type:"dock",initializedBorders:-1,horizontalCollapsePolicy:{width:true,x:true},verticalCollapsePolicy:{height:true,y:true},finishRender:function(){var b=this,c,a;b.callParent();c=b.getRenderTarget();a=b.getDockedItems();b.finishRenderItems(c,a)},isItemBoxParent:function(a){return true},isItemShrinkWrap:function(a){return true},dockOpposites:{top:"bottom",right:"left",bottom:"top",left:"right"},handleItemBorders:function(){var m=this,a=m.owner,l,p,e=m.borders,h=m.dockOpposites,b=a.dockedItems.generation,g,k,o,n,j,c,d=m.collapsed;if(m.initializedBorders==b||(a.border&&!a.manageBodyBorders)){return}m.initializedBorders=b;m.collapsed=false;p=m.getLayoutItems();m.collapsed=d;l={top:[],right:[],bottom:[],left:[]};for(g=0,k=p.length;g<k;g++){o=p[g];n=o.dock;if(o.ignoreBorderManagement){continue}if(!l[n].satisfied){l[n].push(o);l[n].satisfied=true}if(!l.top.satisfied&&h[n]!=="top"){l.top.push(o)}if(!l.right.satisfied&&h[n]!=="right"){l.right.push(o)}if(!l.bottom.satisfied&&h[n]!=="bottom"){l.bottom.push(o)}if(!l.left.satisfied&&h[n]!=="left"){l.left.push(o)}}if(e){for(j in e){if(e.hasOwnProperty(j)){k=e[j].length;if(!a.manageBodyBorders){for(g=0;g<k;g++){c=e[j][g];if(!c.isDestroyed){c.removeCls(Ext.baseCSSPrefix+"docked-noborder-"+j)}}if(!e[j].satisfied&&!a.bodyBorder){a.removeBodyCls(Ext.baseCSSPrefix+"docked-noborder-"+j)}}else{if(e[j].satisfied){a.setBodyStyle("border-"+j+"-width","")}}}}}for(j in l){if(l.hasOwnProperty(j)){k=l[j].length;if(!a.manageBodyBorders){for(g=0;g<k;g++){l[j][g].addCls(Ext.baseCSSPrefix+"docked-noborder-"+j)}if((!l[j].satisfied&&!a.bodyBorder)||a.bodyBorder===false){a.addBodyCls(Ext.baseCSSPrefix+"docked-noborder-"+j)}}else{if(l[j].satisfied){a.setBodyStyle("border-"+j+"-width","1px")}}}}m.borders=l},beforeLayoutCycle:function(e){var c=this,b=c.owner,g=c.sizeModels.shrinkWrap,d,a;if(b.collapsed){if(b.collapsedVertical()){a=true;e.measureDimensions=1}else{d=true;e.measureDimensions=2}}e.collapsedVert=a;e.collapsedHorz=d;if(a){e.heightModel=g}else{if(d){e.widthModel=g}}},beginLayout:function(d){var k=this,c=k.owner,n=k.getLayoutItems(),b=d.context,g=n.length,l,j,m,a,e,h;k.callParent(arguments);k.handleItemBorders();h=c.getCollapsed();if(h!==k.lastCollapsedState&&Ext.isDefined(k.lastCollapsedState)){if(k.owner.collapsed){d.isCollapsingOrExpanding=1;c.addClsWithUI(c.collapsedCls)}else{d.isCollapsingOrExpanding=2;c.removeClsWithUI(c.collapsedCls);d.lastCollapsedState=k.lastCollapsedState}}k.lastCollapsedState=h;d.dockedItems=l=[];for(j=0;j<g;j++){m=n[j];if(m.rendered){a=b.getCmp(m);a.dockedAt={x:0,y:0};a.offsets=e=Ext.Element.parseBox(m.offsets||{});e.width=e.left+e.right;e.height=e.top+e.bottom;l.push(a)}}d.bodyContext=d.getEl("body")},beginLayoutCycle:function(b){var e=this,l=b.dockedItems,d=l.length,a=e.owner,g=a.frameBody,k=e.lastHeightModel,c,j,h;e.callParent(arguments);if(k&&k.shrinkWrap&&!b.heightModel.shrinkWrap&&!e.owner.manageHeight){a.body.dom.style.marginBottom=""}if(b.widthModel.auto){if(b.widthModel.shrinkWrap){a.el.setWidth(null)}a.body.setWidth(null);if(g){g.setWidth(null)}}if(b.heightModel.auto){a.body.setHeight(null);if(g){g.setHeight(null)}}if(b.collapsedVert){b.setContentHeight(0)}else{if(b.collapsedHorz){b.setContentWidth(0)}}for(c=0;c<d;c++){j=l[c].target;h=j.dock;if(h=="right"){j.el.setLeft(0)}else{if(h!="left"){continue}}}},calculate:function(d){var k=this,c=k.measureAutoDimensions(d,d.measureDimensions),b=d.state,j=b.horzDone,e=b.vertDone,g=d.bodyContext,a,i,h,l;d.borderInfo||d.getBorderInfo();d.paddingInfo||d.getPaddingInfo();d.framingInfo||d.getFraming();g.borderInfo||g.getBorderInfo();g.paddingInfo||g.getPaddingInfo();a=!j&&k.createAxis(d,c.contentWidth,d.widthModel,"left","right","x","width","Width",d.collapsedHorz);i=!e&&k.createAxis(d,c.contentHeight,d.heightModel,"top","bottom","y","height","Height",d.collapsedVert);for(h=0,l=d.dockedItems.length;l--;++h){if(a){k.dockChild(d,a,l,h)}if(i){k.dockChild(d,i,l,h)}}if(a&&k.finishAxis(d,a)){b.horzDone=j=a}if(i&&k.finishAxis(d,i)){b.vertDone=e=i}if(j&&e&&k.finishConstraints(d,j,e)){k.finishPositions(d,j,e)}else{k.done=false}},createAxis:function(o,j,e,n,i,s,m,k,d){var u=0,b=this.owner,g=b["max"+k],c=b["min"+k]||0,l=g!=null,t="set"+k,q,a,r,p,h;if(e.shrinkWrap){if(d){h=0}else{a=o.bodyContext;h=j+a.borderInfo[m]}}else{q=o.borderInfo;r=o.framingInfo;p=o.paddingInfo;h=o.getProp(m);h-=q[i]+p[i]+r[i];u=q[n]+p[n]+r[n]}return{shrinkWrap:e.shrinkWrap,sizeModel:e,begin:u,end:h,collapsed:d,horizontal:s=="x",ignoreFrameBegin:false,ignoreFrameEnd:false,initialSize:h-u,hasMinMaxConstraints:(c||l)&&e.shrinkWrap,minSize:c,maxSize:l?g:1000000000,bodyPosProp:this.owner.manageHeight?s:("margin-"+n),dockBegin:n,dockEnd:i,posProp:s,sizeProp:m,sizePropCap:k,setSize:t,dockedPixelsEnd:0}},dockChild:function(b,c,j,d){var e=this,a=b.dockedItems[c.shrinkWrap?j:d],h=a.target,i=h.dock,g;if(h.ignoreParentFrame&&b.isCollapsingOrExpanding){a.clearMarginCache()}if(i==c.dockBegin){if(c.shrinkWrap){g=e.dockOutwardBegin(b,a,h,c)}else{g=e.dockInwardBegin(b,a,h,c)}}else{if(i==c.dockEnd){if(c.shrinkWrap){g=e.dockOutwardEnd(b,a,h,c)}else{g=e.dockInwardEnd(b,a,h,c)}}else{g=e.dockStretch(b,a,h,c)}}a.dockedAt[c.posProp]=g},dockInwardBegin:function(g,e,d,b){var i=b.begin,h=b.sizeProp,a,c;if(d.ignoreParentFrame){c=d.dock;i-=g.borderInfo[c]+g.paddingInfo[c]+g.framingInfo[c]}if(!d.overlay){a=e.getProp(h)+e.getMarginInfo()[h];b.begin+=a}return i},dockInwardEnd:function(e,d,c,b){var h=b.sizeProp,a=d.getProp(h)+d.getMarginInfo()[h],g=b.end-a;if(!c.overlay){b.end=g}if(c.ignoreParentFrame){g+=e.borderInfo[c.dock]+e.paddingInfo[c.dock]+e.framingInfo[c.dock]}return g},dockOutwardBegin:function(g,e,d,b){var i=b.begin,h=b.sizeProp,c,a;if(b.collapsed){b.ignoreFrameBegin=b.ignoreFrameEnd=true}else{if(d.ignoreParentFrame){c=d.dock;i-=g.borderInfo[c]+g.paddingInfo[c]+g.framingInfo[c];b.ignoreFrameBegin=true}}if(!d.overlay){a=e.getProp(h)+e.getMarginInfo()[h];i-=a;b.begin=i}return i},dockOutwardEnd:function(g,e,d,b){var i=b.end,h=b.sizeProp,c,a;a=e.getProp(h)+e.getMarginInfo()[h];if(b.collapsed){b.ignoreFrameBegin=b.ignoreFrameEnd=true}else{if(d.ignoreParentFrame){c=d.dock;i+=g.borderInfo[c]+g.paddingInfo[c]+g.framingInfo[c];b.ignoreFrameEnd=true}}if(!d.overlay){b.end=i+a;b.dockedPixelsEnd+=a}return i},dockStretch:function(c,b,n,d){var o=n.dock,j=d.sizeProp,a=o=="top"||o=="bottom",e=b.offsets,i=c.borderInfo,m=c.paddingInfo,h=a?"right":"bottom",q=a?"left":"top",l=d.begin+e[q],g,p,k;if(n.stretch!==false){p=d.end-l-e[h];if(n.ignoreParentFrame){k=c.framingInfo;l-=i[q]+m[q]+k[q];p+=i[j]+m[j]+k[j]}g=b.getMarginInfo();p-=g[j];b[d.setSize](p)}return l},finishAxis:function(c,e){var o=e.end-e.begin,l=e.setSize,d=e.dockBegin,i=e.dockEnd,j=c.borderInfo,m=c.paddingInfo,k=c.framingInfo,h=m[d]+j[d]+k[d],g=c.bodyContext,n,a,b;if(e.shrinkWrap){e.delta=-e.begin;a=e.initialSize;if(e.ignoreFrameBegin){e.delta-=j[d];n=-e.begin-h}else{o+=h;e.delta+=m[d]+k[d];n=-e.begin}if(!e.ignoreFrameEnd){o+=m[i]+j[i]+k[i]}e.size=o;if(!e.horizontal&&!this.owner.manageHeight){b=false}}else{e.delta=-j[e.dockBegin];a=o;n=e.begin-h}g[l](a,b);g.setProp(e.bodyPosProp,n);return !isNaN(o)},finishConstraints:function(e,a,h){var j=this.sizeModels,l=a.shrinkWrap,b=h.shrinkWrap,c,k,d,g,i,m;if(l){m=a.size;if(m<a.minSize){i=j.constrainedMin;d=a.minSize}else{if(m>a.maxSize){i=j.constrainedMax;d=a.maxSize}else{d=m}}}if(b){m=h.size;if(m<h.minSize){g=j.constrainedMin;k=h.minSize}else{if(m>h.maxSize){g=j.constrainedMax;k=h.maxSize}else{if(!e.collapsedVert&&!this.owner.manageHeight){c=false;e.bodyContext.setProp("margin-bottom",h.dockedPixelsEnd)}k=m}}}if(i||g){if(i&&g&&i.constrainedMax&&g.constrainedMin){e.invalidate({widthModel:i});return false}if(!e.widthModel.calculatedFromShrinkWrap&&!e.heightModel.calculatedFromShrinkWrap){e.invalidate({widthModel:i,heightModel:g});return false}}if(l){e.setWidth(d);if(i){e.widthModel=i}}if(b){e.setHeight(k,c);if(g){e.heightModel=g}}return true},finishPositions:function(d,a,h){var j=d.dockedItems,c=j.length,g=a.delta,e=h.delta,i,b;for(i=0;i<c;++i){b=j[i];b.setProp("x",g+b.dockedAt.x);b.setProp("y",e+b.dockedAt.y)}},finishedLayout:function(b){var a=this,c=b.target;a.callParent(arguments);if(!b.animatePolicy){if(b.isCollapsingOrExpanding===1){c.afterCollapse(false)}else{if(b.isCollapsingOrExpanding===2){c.afterExpand(false)}}}},getAnimatePolicy:function(c){var b=this,a,d;if(c.isCollapsingOrExpanding==1){a=b.lastCollapsedState}else{if(c.isCollapsingOrExpanding==2){a=c.lastCollapsedState}}if(a=="left"||a=="right"){d=b.horizontalCollapsePolicy}else{if(a=="top"||a=="bottom"){d=b.verticalCollapsePolicy}}return d},getDockedItems:function(c,n){var j=this,e=(c==="visual"),k=e?Ext.ComponentQuery.query("[rendered]",j.owner.dockedItems.items):j.owner.dockedItems.items,h=k&&k.length&&c!==false,b,m,l,g,d,a;if(n==null){l=h&&!e?k.slice():k}else{l=[];for(g=0,a=k.length;g<a;++g){m=k[g].dock;d=(m=="top"||m=="left");if(n?d:!d){l.push(k[g])}}h=h&&l.length}if(h){b=(c=c||"render")=="render";Ext.Array.sort(l,function(o,i){var p,q;if(b&&((p=j.owner.dockOrder[o.dock])!==(q=j.owner.dockOrder[i.dock]))){if(!(p+q)){return p-q}}p=j.getItemWeight(o,c);q=j.getItemWeight(i,c);if((p!==undefined)&&(q!==undefined)){return p-q}return 0})}return l||[]},getItemWeight:function(b,a){var c=b.weight||this.owner.defaultDockWeights[b.dock];return c[a]||c},getLayoutItems:function(){var e=this,b,g,d,c,a;if(e.owner.collapsed){a=e.owner.getCollapsedDockedItems()}else{b=e.getDockedItems("visual");g=b.length;a=[];for(c=0;c<g;c++){d=b[c];if(!d.hidden){a.push(d)}}}return a},measureContentWidth:function(a){var b=a.bodyContext;return b.el.getWidth()-b.getBorderInfo().width},measureContentHeight:function(a){var b=a.bodyContext;return b.el.getHeight()-b.getBorderInfo().height},redoLayout:function(c){var b=this,a=b.owner;if(c.isCollapsingOrExpanding==1){if(a.reExpander){a.reExpander.el.show()}a.addClsWithUI(a.collapsedCls);c.redo(true)}else{if(c.isCollapsingOrExpanding==2){a.removeClsWithUI(a.collapsedCls);c.bodyContext.redo()}}},renderChildren:function(){var b=this,a=b.getDockedItems(),c=b.getRenderTarget();b.renderItems(a,c)},renderItems:function(k,h){var l=this,c=k.length,a=0,b=0,p=0,m=l.getRenderTarget().dom.childNodes,n=m.length,g,d,e,o;for(g=0,d=0;g<n;g++){e=m[g];if(Ext.fly(e).hasCls("x-resizable-handle")){break}for(d=0;d<c;d++){o=k[d];if(o.rendered&&o.el.dom===e){break}}if(d===c){p++}}for(;a<c;a++,b++){o=k[a];if(a===b&&(o.dock==="right"||o.dock==="bottom")){b+=p}if(o&&!o.rendered){l.renderItem(o,h,b)}else{if(!l.isValidParent(o,h,b)){l.moveItem(o,h,b)}}}},undoLayout:function(c){var b=this,a=b.owner;if(c.isCollapsingOrExpanding==1){if(a.reExpander){a.reExpander.el.hide()}a.removeClsWithUI(a.collapsedCls);c.undo(true)}else{if(c.isCollapsingOrExpanding==2){a.addClsWithUI(a.collapsedCls);c.bodyContext.undo()}}},sizePolicy:{nostretch:{setsWidth:0,setsHeight:0},stretchH:{setsWidth:1,setsHeight:0},stretchV:{setsWidth:0,setsHeight:1},autoStretchH:{readsWidth:1,setsWidth:1,setsHeight:0},autoStretchV:{readsHeight:1,setsWidth:0,setsHeight:1}},getItemSizePolicy:function(c){var d=this.sizePolicy,b,a;if(c.stretch===false){return d.nostretch}b=c.dock;a=(b=="left"||b=="right");if(a){return d.stretchV}return d.stretchH},configureItem:function(a,b){this.callParent(arguments);a.addCls(Ext.baseCSSPrefix+"docked");a.addClsWithUI("docked-"+a.dock)},afterRemove:function(a){this.callParent(arguments);if(this.itemCls){a.el.removeCls(this.itemCls+"-"+a.dock)}var b=a.el.dom;if(!a.destroying&&b){b.parentNode.removeChild(b)}this.childrenChanged=true}});Ext.define("Ext.toolbar.Fill",{extend:"Ext.Component",alias:"widget.tbfill",alternateClassName:"Ext.Toolbar.Fill",isFill:true,flex:1});Ext.define("Ext.layout.container.boxOverflow.None",{alternateClassName:"Ext.layout.boxOverflow.None",constructor:function(b,a){this.layout=b;Ext.apply(this,a)},handleOverflow:Ext.emptyFn,clearOverflow:Ext.emptyFn,beginLayout:Ext.emptyFn,beginLayoutCycle:Ext.emptyFn,finishedLayout:Ext.emptyFn,completeLayout:function(b){var a=this,c=b.state.boxPlan,d;if(c&&c.tooNarrow){d=a.handleOverflow(b);if(d){if(d.reservedSpace){a.layout.publishInnerCtSize(b,d.reservedSpace)}}}else{a.clearOverflow()}},onRemove:Ext.emptyFn,getItem:function(a){return this.layout.owner.getComponent(a)},getOwnerType:function(a){var b;if(a.isToolbar){b="toolbar"}else{if(a.isTabBar){b="tabbar"}else{if(a.isMenu){b="menu"}else{b=a.getXType()}}}return b},getPrefixConfig:Ext.emptyFn,getSuffixConfig:Ext.emptyFn,getOverflowCls:function(){return""}});Ext.define("Ext.toolbar.Item",{extend:"Ext.Component",alias:"widget.tbitem",alternateClassName:"Ext.Toolbar.Item",enable:Ext.emptyFn,disable:Ext.emptyFn,focus:Ext.emptyFn});Ext.define("Ext.toolbar.Separator",{extend:"Ext.toolbar.Item",alias:"widget.tbseparator",alternateClassName:"Ext.Toolbar.Separator",baseCls:Ext.baseCSSPrefix+"toolbar-separator",focusable:false,border:true});Ext.define("Ext.layout.component.Button",{alias:["layout.button"],extend:"Ext.layout.component.Auto",type:"button",cellClsRE:/-btn-(tl|br)\b/,htmlRE:/<.*>/,constructor:function(){this.callParent(arguments);this.hackWidth=Ext.isIE&&(!Ext.isStrict||Ext.isIE6||Ext.isIE7||Ext.isIE8);this.heightIncludesPadding=Ext.isIE6&&Ext.isStrict},beginLayout:function(a){this.callParent(arguments);this.cacheTargetInfo(a)},beginLayoutCycle:function(e){var c=this,d="",a=c.owner,b=a.btnEl,i=a.btnInnerEl,g=a.text,h;c.callParent(arguments);i.setStyle("overflow",d);if(!e.widthModel.natural){a.el.setStyle("width",d)}h=e.heightModel.shrinkWrap&&g&&c.htmlRE.test(g);b.setStyle("width",d);b.setStyle("height",h?"auto":d);i.setStyle("width",d);i.setStyle("height",h?"auto":d);i.setStyle("line-height",h?"normal":d);i.setStyle("padding-top",d);a.btnIconEl.setStyle("width",d)},calculateOwnerHeightFromContentHeight:function(b,a){return a},calculateOwnerWidthFromContentWidth:function(b,a){return a},measureContentWidth:function(c){var i=this,b=i.owner,g=b.btnEl,d=b.btnInnerEl,l=b.text,m,j,h,a,k,e;if(b.text&&i.hackWidth&&g){m=i.btnFrameWidth;if(l.indexOf(">")===-1){l=l.replace(/</g,"&lt;")}j=Ext.util.TextMetrics.measure(d,l);a=j.width+m+i.adjWidth;k=c.getEl("btnEl");e=c.getEl("btnInnerEl");h=(b.icon||b.iconCls)&&(b.iconAlign=="top"||b.iconAlign=="bottom");c.setWidth(a);k.setWidth(j.width+m);e.setWidth(j.width+m);if(h){b.btnIconEl.setWidth(j.width+m)}}else{a=c.el.getWidth()}return a},measureContentHeight:function(d){var j=this,b=j.owner,e=b.btnInnerEl,i=d.getEl("btnEl"),g=d.getEl("btnInnerEl"),c=j.minTextHeight,h=j.adjHeight,m=b.getText(),l,k,a;if(b.vertical){l=Ext.util.TextMetrics.measure(e,b.text).width;l+=j.btnFrameHeight+h;d.setHeight(l,true,true)}else{if(m&&j.htmlRE.test(m)){k=e.getHeight();if(k<c){a=Math.floor((c-k)/2);g.setHeight(c-(j.heightIncludesPadding?a:0));g.setProp("padding-top",a);k=c}l=k+h}else{l=d.el.getHeight()}}i.setHeight(l-h);return l},publishInnerHeight:function(c,m){var j=this,a=j.owner,g=Ext.isNumber,i=c.getEl("btnEl"),d=a.btnInnerEl,h=c.getEl("btnInnerEl"),e=g(m)?m-j.adjHeight:m,b=j.btnFrameHeight,l=a.getText(),k,n;i.setHeight(e);h.setHeight(e);if(!a.vertical&&e>=0){h.setProp("line-height",e-b+"px")}if(l&&j.htmlRE.test(l)){h.setProp("line-height","normal");d.setStyle("line-height","normal");k=Ext.util.TextMetrics.measure(d,l).height;n=Math.floor(Math.max(e-b-k,0)/2);h.setProp("padding-top",j.btnFrameTop+n);h.setHeight(e-(j.heightIncludesPadding?n:0))}},publishInnerWidth:function(g,c){var e=this,h=Ext.isNumber,a=g.getEl("btnEl"),b=g.getEl("btnInnerEl"),d=h(c)?c-e.adjWidth:c;a.setWidth(d);b.setWidth(d)},clearTargetCache:function(){delete this.adjWidth},cacheTargetInfo:function(b){var g=this,a=g.owner,d=a.scale,i,e,j,c,h;if(!("adjWidth" in g)||g.lastScale!==d){if(g.lastScale){a.btnInnerEl.setStyle("line-height","")}g.lastScale=d;i=b.getPaddingInfo();e=b.getFrameInfo();j=b.getEl("btnWrap").getPaddingInfo();c=b.getEl("btnInnerEl");h=c.getPaddingInfo();Ext.apply(g,{adjWidth:j.width+e.width+i.width,adjHeight:j.height+e.height+i.height,btnFrameWidth:h.width,btnFrameHeight:h.height,btnFrameTop:h.top,minTextHeight:parseInt(c.getStyle("line-height"),10)})}g.callParent(arguments)},finishedLayout:function(){var a=this.owner;this.callParent(arguments);if(Ext.isWebKit){a.el.dom.offsetWidth}}});Ext.define("Ext.menu.Manager",{singleton:true,requires:["Ext.util.MixedCollection","Ext.util.KeyMap"],alternateClassName:"Ext.menu.MenuMgr",uses:["Ext.menu.Menu"],menus:{},groups:{},attached:false,lastShow:new Date(),init:function(){var a=this;a.active=new Ext.util.MixedCollection();Ext.getDoc().addKeyListener(27,function(){if(a.active.length>0){a.hideAll()}},a)},hideAll:function(){var c=this.active,e,b,a,d;if(c&&c.length>0){e=c.clone();b=e.items;d=b.length;for(a=0;a<d;a++){b[a].hide()}return true}return false},onHide:function(a){var b=this,c=b.active;c.remove(a);if(c.length<1){Ext.getDoc().un("mousedown",b.onMouseDown,b);b.attached=false}},onShow:function(a){var e=this,g=e.active,d=g.last(),c=e.attached,b=a.getEl(),h;e.lastShow=new Date();g.add(a);if(!c){Ext.getDoc().on("mousedown",e.onMouseDown,e,{buffer:Ext.isIE?10:undefined});e.attached=true}a.toFront()},onBeforeHide:function(a){if(a.activeChild){a.activeChild.hide()}if(a.autoHideTimer){clearTimeout(a.autoHideTimer);delete a.autoHideTimer}},onBeforeShow:function(a){var c=this.active,b=a.parentMenu;c.remove(a);if(!b&&!a.allowOtherMenus){this.hideAll()}else{if(b&&b.activeChild&&a!=b.activeChild){b.activeChild.hide()}}},onMouseDown:function(d){var b=this,c=b.active,a=b.lastShow;if(Ext.Date.getElapsed(a)>50&&c.length>0&&!d.getTarget("."+Ext.baseCSSPrefix+"menu")){b.hideAll()}},register:function(b){var a=this;if(!a.active){a.init()}if(b.floating){a.menus[b.id]=b;b.on({beforehide:a.onBeforeHide,hide:a.onHide,beforeshow:a.onBeforeShow,show:a.onShow,scope:a})}},get:function(b){var a=this.menus;if(typeof b=="string"){if(!a){return null}return a[b]}else{if(b.isMenu){return b}else{if(Ext.isArray(b)){return new Ext.menu.Menu({items:b})}else{return Ext.ComponentManager.create(b,"menu")}}}},unregister:function(d){var a=this,b=a.menus,c=a.active;delete b[d.id];c.remove(d);d.un({beforehide:a.onBeforeHide,hide:a.onHide,beforeshow:a.onBeforeShow,show:a.onShow,scope:a})},registerCheckable:function(c){var a=this.groups,b=c.group;if(b){if(!a[b]){a[b]=[]}a[b].push(c)}},unregisterCheckable:function(c){var a=this.groups,b=c.group;if(b){Ext.Array.remove(a[b],c)}},onCheckChange:function(d,g){var a=this.groups,c=d.group,b=0,j,e,h;if(c&&g){j=a[c];e=j.length;for(;b<e;b++){h=j[b];if(h!=d){h.setChecked(false)}}}}});Ext.define("Ext.util.ClickRepeater",{extend:"Ext.util.Observable",constructor:function(b,a){var c=this;c.el=Ext.get(b);c.el.unselectable();Ext.apply(c,a);c.callParent();c.addEvents("mousedown","click","mouseup");if(!c.disabled){c.disabled=true;c.enable()}if(c.handler){c.on("click",c.handler,c.scope||c)}},interval:20,delay:250,preventDefault:true,stopDefault:false,timer:0,enable:function(){if(this.disabled){this.el.on("mousedown",this.handleMouseDown,this);if(Ext.isIE&&!(Ext.isStrict&&Ext.isIE9)){this.el.on("dblclick",this.handleDblClick,this)}if(this.preventDefault||this.stopDefault){this.el.on("click",this.eventOptions,this)}}this.disabled=false},disable:function(a){if(a||!this.disabled){clearTimeout(this.timer);if(this.pressedCls){this.el.removeCls(this.pressedCls)}Ext.getDoc().un("mouseup",this.handleMouseUp,this);this.el.removeAllListeners()}this.disabled=true},setDisabled:function(a){this[a?"disable":"enable"]()},eventOptions:function(a){if(this.preventDefault){a.preventDefault()}if(this.stopDefault){a.stopEvent()}},destroy:function(){this.disable(true);Ext.destroy(this.el);this.clearListeners()},handleDblClick:function(a){clearTimeout(this.timer);this.el.blur();this.fireEvent("mousedown",this,a);this.fireEvent("click",this,a)},handleMouseDown:function(a){clearTimeout(this.timer);this.el.blur();if(this.pressedCls){this.el.addCls(this.pressedCls)}this.mousedownTime=new Date();Ext.getDoc().on("mouseup",this.handleMouseUp,this);this.el.on("mouseout",this.handleMouseOut,this);this.fireEvent("mousedown",this,a);this.fireEvent("click",this,a);if(this.accelerate){this.delay=400}a=new Ext.EventObjectImpl(a);this.timer=Ext.defer(this.click,this.delay||this.interval,this,[a])},click:function(a){this.fireEvent("click",this,a);this.timer=Ext.defer(this.click,this.accelerate?this.easeOutExpo(Ext.Date.getElapsed(this.mousedownTime),400,-390,12000):this.interval,this,[a])},easeOutExpo:function(e,a,h,g){return(e==g)?a+h:h*(-Math.pow(2,-10*e/g)+1)+a},handleMouseOut:function(){clearTimeout(this.timer);if(this.pressedCls){this.el.removeCls(this.pressedCls)}this.el.on("mouseover",this.handleMouseReturn,this)},handleMouseReturn:function(){this.el.un("mouseover",this.handleMouseReturn,this);if(this.pressedCls){this.el.addCls(this.pressedCls)}this.click()},handleMouseUp:function(a){clearTimeout(this.timer);this.el.un("mouseover",this.handleMouseReturn,this);this.el.un("mouseout",this.handleMouseOut,this);Ext.getDoc().un("mouseup",this.handleMouseUp,this);if(this.pressedCls){this.el.removeCls(this.pressedCls)}this.fireEvent("mouseup",this,a)}});Ext.define("Ext.util.TextMetrics",{statics:{shared:null,measure:function(a,d,e){var b=this,c=b.shared;if(!c){c=b.shared=new b(a,e)}c.bind(a);c.setFixedWidth(e||"auto");return c.getSize(d)},destroy:function(){var a=this;Ext.destroy(a.shared);a.shared=null}},constructor:function(a,c){var b=this.measure=Ext.getBody().createChild({cls:Ext.baseCSSPrefix+"textmetrics"});this.el=Ext.get(a);b.position("absolute");b.setLeftTop(-1000,-1000);b.hide();if(c){b.setWidth(c)}},getSize:function(c){var b=this.measure,a;b.update(c);a=b.getSize();b.update("");return a},bind:function(a){var b=this;b.el=Ext.get(a);b.measure.setStyle(b.el.getStyles("font-size","font-style","font-weight","font-family","line-height","text-transform","letter-spacing"))},setFixedWidth:function(a){this.measure.setWidth(a)},getWidth:function(a){this.measure.dom.style.width="auto";return this.getSize(a).width},getHeight:function(a){return this.getSize(a).height},destroy:function(){var a=this;a.measure.remove();delete a.el;delete a.measure}},function(){Ext.Element.addMethods({getTextWidth:function(c,b,a){return Ext.Number.constrain(Ext.util.TextMetrics.measure(this.dom,Ext.value(c,this.dom.innerHTML,true)).width,b||0,a||1000000)}})});Ext.define("Ext.button.Button",{alias:"widget.button",extend:"Ext.Component",requires:["Ext.menu.Manager","Ext.util.ClickRepeater","Ext.layout.component.Button","Ext.util.TextMetrics","Ext.util.KeyMap"],alternateClassName:"Ext.Button",isButton:true,componentLayout:"button",hidden:false,disabled:false,pressed:false,enableToggle:false,menuAlign:"tl-bl?",textAlign:"center",type:"button",clickEvent:"click",preventDefault:true,handleMouseEvents:true,tooltipType:"qtip",baseCls:Ext.baseCSSPrefix+"btn",pressedCls:"pressed",overCls:"over",focusCls:"focus",menuActiveCls:"menu-active",hrefTarget:"_blank",border:true,childEls:["btnEl","btnWrap","btnInnerEl","btnIconEl"],renderTpl:['<em id="{id}-btnWrap"<tpl if="splitCls"> class="{splitCls}"</tpl>>','<tpl if="href">','<a id="{id}-btnEl" href="{href}" class="{btnCls}" target="{hrefTarget}"','<tpl if="tabIndex"> tabIndex="{tabIndex}"</tpl>','<tpl if="disabled"> disabled="disabled"</tpl>',' role="link">','<span id="{id}-btnInnerEl" class="{baseCls}-inner">',"{text}","</span>",'<span id="{id}-btnIconEl" class="{baseCls}-icon {iconCls}"<tpl if="iconUrl"> style="background-image:url({iconUrl})"</tpl>></span>',"</a>","<tpl else>",'<button id="{id}-btnEl" type="{type}" class="{btnCls}" hidefocus="true"','<tpl if="tabIndex"> tabIndex="{tabIndex}"</tpl>','<tpl if="disabled"> disabled="disabled"</tpl>',' role="button" autocomplete="off">','<span id="{id}-btnInnerEl" class="{baseCls}-inner" style="{innerSpanStyle}">',"{text}","</span>",'<span id="{id}-btnIconEl" class="{baseCls}-icon {iconCls}"<tpl if="iconUrl"> style="background-image:url({iconUrl})"</tpl>></span>',"</button>","</tpl>","</em>",'<tpl if="closable">','<a id="{id}-closeEl" href="#" class="{baseCls}-close-btn" title="{closeText}"></a>',"</tpl>"],scale:"small",allowedScales:["small","medium","large"],iconAlign:"left",arrowAlign:"right",arrowCls:"arrow",maskOnDisable:false,persistentPadding:undefined,shrinkWrap:3,frame:true,initComponent:function(){var a=this;a.callParent(arguments);a.addEvents("click","toggle","mouseover","mouseout","menushow","menuhide","menutriggerover","menutriggerout");if(a.menu){a.split=true;a.menu=Ext.menu.Manager.get(a.menu);a.menu.ownerButton=a}if(a.url){a.href=a.url}if(a.href&&!a.hasOwnProperty("preventDefault")){a.preventDefault=false}if(Ext.isString(a.toggleGroup)&&a.toggleGroup!==""){a.enableToggle=true}if(a.html&&!a.text){a.text=a.html;delete a.html}},getActionEl:function(){return this.btnEl},getFocusEl:function(){return this.useElForFocus?this.el:this.btnEl},onFocus:function(b){var a=this;a.useElForFocus=true;a.callParent(arguments);a.useElForFocus=false},onBlur:function(a){this.useElForFocus=true;this.callParent(arguments);this.useElForFocus=false},onDisable:function(){this.useElForFocus=true;this.callParent(arguments);this.useElForFocus=false},setComponentCls:function(){var b=this,a=b.getComponentCls();if(!Ext.isEmpty(b.oldCls)){b.removeClsWithUI(b.oldCls);b.removeClsWithUI(b.pressedCls)}b.oldCls=a;b.addClsWithUI(a)},getComponentCls:function(){var b=this,a=[];if(b.iconCls||b.icon){if(b.text){a.push("icon-text-"+b.iconAlign)}else{a.push("icon")}}else{if(b.text){a.push("noicon")}}if(b.pressed){a.push(b.pressedCls)}return a},beforeRender:function(){var a=this;a.callParent();a.oldCls=a.getComponentCls();a.addClsWithUI(a.oldCls);Ext.applyIf(a.renderData,a.getTemplateArgs());if(a.scale){a.setScale(a.scale)}},onRender:function(){var c=this,d,a,b;c.doc=Ext.getDoc();c.callParent(arguments);if(c.split&&c.arrowTooltip){c.arrowEl.dom.setAttribute(c.getTipAttr(),c.arrowTooltip)}a=c.el;if(c.tooltip){c.setTooltip(c.tooltip,true)}if(c.handleMouseEvents){b={scope:c,mouseover:c.onMouseOver,mouseout:c.onMouseOut,mousedown:c.onMouseDown};if(c.split){b.mousemove=c.onMouseMove}}else{b={scope:c}}if(c.menu){c.mon(c.menu,{scope:c,show:c.onMenuShow,hide:c.onMenuHide});c.keyMap=new Ext.util.KeyMap({target:c.el,key:Ext.EventObject.DOWN,handler:c.onDownKey,scope:c})}if(c.repeat){c.mon(new Ext.util.ClickRepeater(a,Ext.isObject(c.repeat)?c.repeat:{}),"click",c.onRepeatClick,c)}else{if(b[c.clickEvent]){d=true}else{b[c.clickEvent]=c.onClick}}c.mon(a,b);if(d){c.mon(a,c.clickEvent,c.onClick,c)}Ext.ButtonToggleManager.register(c)},getTemplateArgs:function(){var c=this,b=c.getPersistentPadding(),a="";if(Math.max.apply(Math,b)>0){a="margin:"+Ext.Array.map(b,function(d){return -d+"px"}).join(" ")}return{href:c.getHref(),disabled:c.disabled,hrefTarget:c.hrefTarget,type:c.type,btnCls:c.getBtnCls(),splitCls:c.getSplitCls(),iconUrl:c.icon,iconCls:c.iconCls,text:c.text||"&#160;",tabIndex:c.tabIndex,innerSpanStyle:a}},getHref:function(){var a=this,b=Ext.apply({},a.baseParams);b=Ext.apply(b,a.params);return a.href?Ext.urlAppend(a.href,Ext.Object.toQueryString(b)):false},setParams:function(a){this.params=a;this.btnEl.dom.href=this.getHref()},getSplitCls:function(){var a=this;return a.split?(a.baseCls+"-"+a.arrowCls)+" "+(a.baseCls+"-"+a.arrowCls+"-"+a.arrowAlign):""},getBtnCls:function(){return this.textAlign?this.baseCls+"-"+this.textAlign:""},setIconCls:function(b){var d=this,a=d.btnIconEl,c=d.iconCls;d.iconCls=b;if(a){a.removeCls(c);a.addCls(b||"");d.setComponentCls();if(d.didIconStateChange(c,b)){d.updateLayout()}}return d},setTooltip:function(c,a){var b=this;if(b.rendered){if(!a){b.clearTip()}if(Ext.isObject(c)){Ext.tip.QuickTipManager.register(Ext.apply({target:b.btnEl.id},c));b.tooltip=c}else{b.btnEl.dom.setAttribute(b.getTipAttr(),c)}}else{b.tooltip=c}return b},setTextAlign:function(c){var b=this,a=b.btnEl;if(a){a.removeCls(b.baseCls+"-"+b.textAlign);a.addCls(b.baseCls+"-"+c)}b.textAlign=c;return b},getTipAttr:function(){return this.tooltipType=="qtip"?"data-qtip":"title"},getRefItems:function(a){var c=this.menu,b;if(c){b=c.getRefItems(a);b.unshift(c)}return b||[]},clearTip:function(){if(Ext.isObject(this.tooltip)){Ext.tip.QuickTipManager.unregister(this.btnEl)}},beforeDestroy:function(){var a=this;if(a.rendered){a.clearTip()}if(a.menu&&a.destroyMenu!==false){Ext.destroy(a.menu)}Ext.destroy(a.btnInnerEl,a.repeater);a.callParent()},onDestroy:function(){var a=this;if(a.rendered){a.doc.un("mouseover",a.monitorMouseOver,a);a.doc.un("mouseup",a.onMouseUp,a);delete a.doc;Ext.ButtonToggleManager.unregister(a);Ext.destroy(a.keyMap);delete a.keyMap}a.callParent()},setHandler:function(b,a){this.handler=b;this.scope=a;return this},setText:function(b){var a=this;a.text=b;if(a.rendered){a.btnInnerEl.update(b||"&#160;");a.setComponentCls();if(Ext.isStrict&&Ext.isIE8){a.el.repaint()}a.updateLayout()}return a},setIcon:function(b){var c=this,a=c.btnIconEl,d=c.icon;c.icon=b;if(a){a.setStyle("background-image",b?"url("+b+")":"");c.setComponentCls();if(c.didIconStateChange(d,b)){c.updateLayout()}}return c},didIconStateChange:function(a,c){var b=Ext.isEmpty(c);return Ext.isEmpty(a)?!b:b},getText:function(){return this.text},toggle:function(c,a){var b=this;c=c===undefined?!b.pressed:!!c;if(c!==b.pressed){if(b.rendered){b[c?"addClsWithUI":"removeClsWithUI"](b.pressedCls)}b.pressed=c;if(!a){b.fireEvent("toggle",b,c);Ext.callback(b.toggleHandler,b.scope||b,[b,c])}}return b},maybeShowMenu:function(){var a=this;if(a.menu&&!a.hasVisibleMenu()&&!a.ignoreNextClick){a.showMenu()}},showMenu:function(){var a=this;if(a.rendered&&a.menu){if(a.tooltip&&a.getTipAttr()!="title"){Ext.tip.QuickTipManager.getQuickTip().cancelShow(a.btnEl)}if(a.menu.isVisible()){a.menu.hide()}a.menu.showBy(a.el,a.menuAlign,((!Ext.isStrict&&Ext.isIE)||Ext.isIE6)?[-2,-2]:undefined)}return a},hideMenu:function(){if(this.hasVisibleMenu()){this.menu.hide()}return this},hasVisibleMenu:function(){var a=this.menu;return a&&a.rendered&&a.isVisible()},onRepeatClick:function(a,b){this.onClick(b)},onClick:function(b){var a=this;if(a.preventDefault||(a.disabled&&a.getHref())&&b){b.preventDefault()}if(b.button!==0){return}if(!a.disabled){a.doToggle();a.maybeShowMenu();a.fireHandler(b)}},fireHandler:function(c){var b=this,a=b.handler;if(b.fireEvent("click",b,c)!==false){if(a){a.call(b.scope||b,b,c)}b.blur()}},doToggle:function(){var a=this;if(a.enableToggle&&(a.allowDepress!==false||!a.pressed)){a.toggle()}},onMouseOver:function(b){var a=this;if(!a.disabled&&!b.within(a.el,true,true)){a.onMouseEnter(b)}},onMouseOut:function(b){var a=this;if(!b.within(a.el,true,true)){if(a.overMenuTrigger){a.onMenuTriggerOut(b)}a.onMouseLeave(b)}},onMouseMove:function(h){var d=this,c=d.el,g=d.overMenuTrigger,b,a;if(d.split){if(d.arrowAlign==="right"){b=h.getX()-c.getX();a=c.getWidth()}else{b=h.getY()-c.getY();a=c.getHeight()}if(b>(a-d.getTriggerSize())){if(!g){d.onMenuTriggerOver(h)}}else{if(g){d.onMenuTriggerOut(h)}}}},getTriggerSize:function(){var e=this,c=e.triggerSize,b,a,d;if(c===d){b=e.arrowAlign;a=b.charAt(0);c=e.triggerSize=e.el.getFrameWidth(a)+e.btnWrap.getFrameWidth(a)+e.frameSize[b]}return c},onMouseEnter:function(b){var a=this;a.addClsWithUI(a.overCls);a.fireEvent("mouseover",a,b)},onMouseLeave:function(b){var a=this;a.removeClsWithUI(a.overCls);a.fireEvent("mouseout",a,b)},onMenuTriggerOver:function(b){var a=this;a.overMenuTrigger=true;a.fireEvent("menutriggerover",a,a.menu,b)},onMenuTriggerOut:function(b){var a=this;delete a.overMenuTrigger;a.fireEvent("menutriggerout",a,a.menu,b)},enable:function(a){var b=this;b.callParent(arguments);if(b.btnEl){b.btnEl.dom.disabled=false}b.removeClsWithUI("disabled");return b},disable:function(a){var b=this;b.callParent(arguments);if(b.btnEl){b.btnEl.dom.disabled=true}b.addClsWithUI("disabled");b.removeClsWithUI(b.overCls);if(b.btnInnerEl&&(Ext.isIE6||Ext.isIE7)){b.btnInnerEl.repaint()}return b},setScale:function(c){var a=this,b=a.ui.replace("-"+a.scale,"");if(!Ext.Array.contains(a.allowedScales,c)){throw ("#setScale: scale must be an allowed scale ("+a.allowedScales.join(", ")+")")}a.scale=c;a.setUI(b)},setUI:function(b){var a=this;if(a.scale&&!b.match(a.scale)){b=b+"-"+a.scale}a.callParent([b])},onMouseDown:function(b){var a=this;if(!a.disabled&&b.button===0){a.addClsWithUI(a.pressedCls);a.doc.on("mouseup",a.onMouseUp,a)}},onMouseUp:function(b){var a=this;if(b.button===0){if(!a.pressed){a.removeClsWithUI(a.pressedCls)}a.doc.un("mouseup",a.onMouseUp,a)}},onMenuShow:function(b){var a=this;a.ignoreNextClick=0;a.addClsWithUI(a.menuActiveCls);a.fireEvent("menushow",a,a.menu)},onMenuHide:function(b){var a=this;a.removeClsWithUI(a.menuActiveCls);a.ignoreNextClick=Ext.defer(a.restoreClick,250,a);a.fireEvent("menuhide",a,a.menu)},restoreClick:function(){this.ignoreNextClick=0},onDownKey:function(){var a=this;if(!a.disabled){if(a.menu){a.showMenu()}}},getPersistentPadding:function(){var g=this,e=Ext.scopeResetCSS,h=g.persistentPadding,b,a,d,i,c;if(!h){h=g.self.prototype.persistentPadding=[0,0,0,0];if(!Ext.isIE){b=new Ext.button.Button({text:"test",style:"position:absolute;top:-999px;"});b.el=Ext.DomHelper.append(Ext.resetElement,b.getRenderTree(),true);b.applyChildEls(b.el);d=b.btnEl;i=b.btnInnerEl;d.setSize(null,null);a=i.getOffsetsTo(d);h[0]=a[1];h[1]=d.getWidth()-i.getWidth()-a[0];h[2]=d.getHeight()-i.getHeight()-a[1];h[3]=a[0];b.destroy();b.el.remove()}}return h}},function(){var a={},b=function(d,j){if(j){var h=a[d.toggleGroup],e=h.length,c;for(c=0;c<e;c++){if(h[c]!==d){h[c].toggle(false)}}}};Ext.ButtonToggleManager={register:function(c){if(!c.toggleGroup){return}var d=a[c.toggleGroup];if(!d){d=a[c.toggleGroup]=[]}d.push(c);c.on("toggle",b)},unregister:function(c){if(!c.toggleGroup){return}var d=a[c.toggleGroup];if(d){Ext.Array.remove(d,c);c.un("toggle",b)}},getPressed:function(h){var e=a[h],d=0,c;if(e){for(c=e.length;d<c;d++){if(e[d].pressed===true){return e[d]}}}return null}}});Ext.define("Ext.layout.container.boxOverflow.Menu",{extend:"Ext.layout.container.boxOverflow.None",requires:["Ext.toolbar.Separator","Ext.button.Button"],alternateClassName:"Ext.layout.boxOverflow.Menu",noItemsMenuText:'<div class="'+Ext.baseCSSPrefix+'toolbar-no-items">(None)</div>',constructor:function(b){var a=this;a.callParent(arguments);a.triggerButtonCls=a.triggerButtonCls||Ext.baseCSSPrefix+"box-menu-"+b.getNames().right;a.menuItems=[]},beginLayout:function(a){this.callParent(arguments);this.clearOverflow(a)},beginLayoutCycle:function(b,a){this.callParent(arguments);if(!a){this.clearOverflow(b);this.layout.cacheChildItems(b)}},onRemove:function(a){Ext.Array.remove(this.menuItems,a)},getSuffixConfig:function(){var c=this,b=c.layout,a=b.owner.id;c.menu=new Ext.menu.Menu({listeners:{scope:c,beforeshow:c.beforeMenuShow}});c.menuTrigger=new Ext.button.Button({id:a+"-menu-trigger",cls:Ext.layout.container.Box.prototype.innerCls+" "+c.triggerButtonCls,hidden:true,ownerCt:b.owner,ownerLayout:b,iconCls:Ext.baseCSSPrefix+c.getOwnerType(b.owner)+"-more-icon",ui:b.owner instanceof Ext.toolbar.Toolbar?"default-toolbar":"default",menu:c.menu,getSplitCls:function(){return""}});return c.menuTrigger.getRenderTree()},getOverflowCls:function(){return Ext.baseCSSPrefix+this.layout.direction+"-box-overflow-body"},handleOverflow:function(d){var c=this,b=c.layout,g=b.getNames(),e=d.state.boxPlan,a=[null,null];c.showTrigger(d);a[g.heightIndex]=(e.maxSize-c.menuTrigger[g.getHeight]())/2;c.menuTrigger.setPosition.apply(c.menuTrigger,a);return{reservedSpace:c.menuTrigger[g.getWidth]()}},captureChildElements:function(){var a=this.menuTrigger;if(a.rendering){a.finishRender()}},_asLayoutRoot:{isRoot:true},clearOverflow:function(h){var g=this,b=g.menuItems,e,c=0,d=b.length,a=g.layout.owner,j=g._asLayoutRoot;a.suspendLayouts();g.captureChildElements();g.hideTrigger();a.resumeLayouts();for(;c<d;c++){e=b[c];e.suspendLayouts();e.show();e.resumeLayouts(j)}b.length=0},showTrigger:function(c){var o=this,k=o.layout,a=k.owner,n=k.getNames(),r=n.x,e=n.width,p=c.state.boxPlan,b=p.targetSize[e],h=c.childItems,l=h.length,g=o.menuTrigger,q,j,d,m;g.suspendLayouts();g.show();g.resumeLayouts(o._asLayoutRoot);b-=o.menuTrigger.getWidth();a.suspendLayouts();o.menuItems.length=0;for(d=0;d<l;d++){q=h[d];m=q.props;if(m[r]+m[e]>b){j=q.target;o.menuItems.push(j);j.hide()}}a.resumeLayouts()},hideTrigger:function(){var a=this.menuTrigger;if(a){a.hide()}},beforeMenuShow:function(j){var h=this,b=h.menuItems,d=0,a=b.length,g,e,c=function(k,i){return k.isXType("buttongroup")&&!(i instanceof Ext.toolbar.Separator)};j.suspendLayouts();h.clearMenu();j.removeAll();for(;d<a;d++){g=b[d];if(!d&&(g instanceof Ext.toolbar.Separator)){continue}if(e&&(c(g,e)||c(e,g))){j.add("-")}h.addComponentToMenu(j,g);e=g}if(j.items.length<1){j.add(h.noItemsMenuText)}j.resumeLayouts()},createMenuConfig:function(c,a){var b=Ext.apply({},c.initialConfig),d=c.toggleGroup;Ext.copyTo(b,c,["iconCls","icon","itemId","disabled","handler","scope","menu"]);Ext.apply(b,{text:c.overflowText||c.text,hideOnClick:a,destroyMenu:false});if(c.isFormField){b.value=c.getValue();if(!b.listeners){b.listeners={}}b.listeners.change=function(h,g,e){c.setValue(g)}}else{if(d||c.enableToggle){Ext.apply(b,{iconAlign:"right",hideOnClick:false,group:d,checked:c.pressed,listeners:{checkchange:function(g,e){c.toggle(e)}}})}}delete b.ownerCt;delete b.xtype;delete b.id;return b},addComponentToMenu:function(g,c){var e=this,d,b,a;if(c instanceof Ext.toolbar.Separator){g.add("-")}else{if(c.isComponent){if(c.isXType("splitbutton")){g.add(e.createMenuConfig(c,true))}else{if(c.isXType("button")){g.add(e.createMenuConfig(c,!c.menu))}else{if(c.isXType("buttongroup")){b=c.items.items;a=b.length;for(d=0;d<a;d++){e.addComponentToMenu(g,b[d])}}else{g.add(Ext.create(Ext.getClassName(c),e.createMenuConfig(c)))}}}}}},clearMenu:function(){var e=this.menu,b,c,a,d;if(e&&e.items){b=e.items.items;a=b.length;for(c=0;c<a;c++){d=b[c];if(d.setMenu){d.setMenu(null)}}}},destroy:function(){var a=this.menuTrigger;if(a&&!this.layout.owner.items.contains(a)){delete a.ownerCt}Ext.destroy(this.menu,a)}});Ext.define("Ext.layout.container.boxOverflow.Scroller",{extend:"Ext.layout.container.boxOverflow.None",requires:["Ext.util.ClickRepeater","Ext.Element"],alternateClassName:"Ext.layout.boxOverflow.Scroller",mixins:{observable:"Ext.util.Observable"},animateScroll:false,scrollIncrement:20,wheelIncrement:10,scrollRepeatInterval:60,scrollDuration:400,scrollerCls:Ext.baseCSSPrefix+"box-scroller",constructor:function(c,a){var b=this;b.layout=c;Ext.apply(b,a||{});b.mixins.observable.constructor.call(b);b.addEvents("scroll");b.scrollPosition=0;b.scrollSize=0},getPrefixConfig:function(){var a=this;a.initCSSClasses();return{cls:Ext.layout.container.Box.prototype.innerCls+" "+a.beforeCtCls,cn:{id:a.layout.owner.id+"-before-scroller",cls:a.scrollerCls+" "+a.beforeScrollerCls,style:"display:none"}}},getSuffixConfig:function(){var a=this;return{cls:Ext.layout.container.Box.prototype.innerCls+" "+a.afterCtCls,cn:{id:a.layout.owner.id+"-after-scroller",cls:a.scrollerCls+" "+a.afterScrollerCls,style:"display:none"}}},getOverflowCls:function(){return Ext.baseCSSPrefix+this.layout.direction+"-box-overflow-body"},initCSSClasses:function(){var d=this,e=Ext.baseCSSPrefix,c=d.layout,g=c.getNames(),a=g.left,h=g.right,b=d.getOwnerType(c.owner);d.beforeCtCls=d.beforeCtCls||e+"box-scroller-"+a;d.afterCtCls=d.afterCtCls||e+"box-scroller-"+h;d.beforeScrollerCls=d.beforeScrollerCls||e+b+"-scroll-"+a;d.afterScrollerCls=d.afterScrollerCls||e+b+"-scroll-"+h},beginLayout:function(b){var a=this.layout,c=a.getNames();b.innerCtScrollPos=a.innerCt.dom["scroll"+c.leftCap];this.callParent(arguments)},completeLayout:function(a){this.scrollSize=a.props["content"+this.layout.getNames().widthCap];this.callParent(arguments)},finishedLayout:function(c){var b=this,a=b.layout,d=a.getNames(),e=Math.min(b.getMaxScrollPosition(),c.innerCtScrollPos);a.innerCt.dom["scroll"+d.leftCap]=e},handleOverflow:function(d){var c=this,b=c.layout,e=b.getNames(),a="get"+e.widthCap;c.captureChildElements();c.showScrollers();return{reservedSpace:c.beforeCt[a]()+c.afterCt[a]()}},captureChildElements:function(){var b=this,a=b.layout.owner.el,c,d;if(!b.beforeCt){c=b.beforeScroller=a.getById(b.layout.owner.id+"-before-scroller");d=b.afterScroller=a.getById(b.layout.owner.id+"-after-scroller");b.beforeCt=c.up("");b.afterCt=d.up("");b.createWheelListener();c.addClsOnOver(b.beforeScrollerCls+"-hover");d.addClsOnOver(b.afterScrollerCls+"-hover");c.setVisibilityMode(Ext.Element.DISPLAY);d.setVisibilityMode(Ext.Element.DISPLAY);b.beforeRepeater=new Ext.util.ClickRepeater(c,{interval:b.scrollRepeatInterval,handler:b.scrollLeft,scope:b});b.afterRepeater=new Ext.util.ClickRepeater(d,{interval:b.scrollRepeatInterval,handler:b.scrollRight,scope:b})}},createWheelListener:function(){this.layout.innerCt.on({mousewheel:function(a){this.scrollBy(a.getWheelDelta()*this.wheelIncrement*-1,false)},stopEvent:true,scope:this})},clearOverflow:function(){var a=this.layout;this.hideScrollers()},showScrollers:function(){var a=this;a.captureChildElements();a.beforeScroller.show();a.afterScroller.show();a.updateScrollButtons();a.layout.owner.addClsWithUI("scroller")},hideScrollers:function(){var a=this;if(a.beforeScroller!==undefined){a.beforeScroller.hide();a.afterScroller.hide();a.layout.owner.removeClsWithUI("scroller")}},destroy:function(){var a=this;Ext.destroy(a.beforeRepeater,a.afterRepeater,a.beforeScroller,a.afterScroller,a.beforeCt,a.afterCt)},scrollBy:function(b,a){this.scrollTo(this.getScrollPosition()+b,a)},getScrollAnim:function(){return{duration:this.scrollDuration,callback:this.updateScrollButtons,scope:this}},updateScrollButtons:function(){var d=this,e,c,a,b;if(d.beforeScroller===undefined||d.afterScroller===undefined){return}e=d.atExtremeBefore()?"addCls":"removeCls";c=d.atExtremeAfter()?"addCls":"removeCls";a=d.beforeScrollerCls+"-disabled";b=d.afterScrollerCls+"-disabled";d.beforeScroller[e](a);d.afterScroller[c](b);d.scrolling=false},atExtremeBefore:function(){return !this.getScrollPosition()},scrollLeft:function(){this.scrollBy(-this.scrollIncrement,false)},scrollRight:function(){this.scrollBy(this.scrollIncrement,false)},getScrollPosition:function(){var c=this,b=c.layout,a;if(c.hasOwnProperty("scrollPosition")){a=c.scrollPosition}else{a=parseInt(b.innerCt.dom["scroll"+b.getNames().leftCap],10)||0}return a},getMaxScrollPosition:function(){var b=this,a=b.layout,c=a.getNames(),d=b.scrollSize-a.innerCt["get"+c.widthCap]();return(d<0)?0:d},atExtremeAfter:function(){return this.getScrollPosition()>=this.getMaxScrollPosition()},scrollTo:function(a,b){var g=this,e=g.layout,h=e.getNames(),d=g.getScrollPosition(),c=Ext.Number.constrain(a,0,g.getMaxScrollPosition());if(c!=d&&!g.scrolling){delete g.scrollPosition;if(b===undefined){b=g.animateScroll}e.innerCt.scrollTo(h.left,c,b?g.getScrollAnim():false);if(b){g.scrolling=true}else{g.updateScrollButtons()}g.fireEvent("scroll",g,c,b?g.getScrollAnim():false)}},scrollToItem:function(h,b){var g=this,e=g.layout,i=e.getNames(),a,d,c;h=g.getItem(h);if(h!==undefined){a=g.getItemVisibility(h);if(!a.fullyVisible){d=h.getBox(true,true);c=d[i.x];if(a.hiddenEnd){c-=(g.layout.innerCt["get"+i.widthCap]()-d[i.width])}g.scrollTo(c,b)}}},getItemVisibility:function(j){var h=this,b=h.getItem(j).getBox(true,true),c=h.layout,g=c.getNames(),e=b[g.x],d=e+b[g.width],a=h.getScrollPosition(),i=a+c.innerCt["get"+g.widthCap]();return{hiddenStart:e<a,hiddenEnd:d>i,fullyVisible:e>a&&d<i}}});Ext.define("Ext.util.Offset",{statics:{fromObject:function(a){return new this(a.x,a.y)}},constructor:function(a,b){this.x=(a!=null&&!isNaN(a))?a:0;this.y=(b!=null&&!isNaN(b))?b:0;return this},copy:function(){return new Ext.util.Offset(this.x,this.y)},copyFrom:function(a){this.x=a.x;this.y=a.y},toString:function(){return"Offset["+this.x+","+this.y+"]"},equals:function(a){return(this.x==a.x&&this.y==a.y)},round:function(b){if(!isNaN(b)){var a=Math.pow(10,b);this.x=Math.round(this.x*a)/a;this.y=Math.round(this.y*a)/a}else{this.x=Math.round(this.x);this.y=Math.round(this.y)}},isZero:function(){return this.x==0&&this.y==0}});Ext.define("Ext.util.Region",{requires:["Ext.util.Offset"],statics:{getRegion:function(a){return Ext.fly(a).getPageBox(true)},from:function(a){return new this(a.top,a.right,a.bottom,a.left)}},constructor:function(d,g,a,c){var e=this;e.y=e.top=e[1]=d;e.right=g;e.bottom=a;e.x=e.left=e[0]=c},contains:function(b){var a=this;return(b.x>=a.x&&b.right<=a.right&&b.y>=a.y&&b.bottom<=a.bottom)},intersect:function(h){var g=this,d=Math.max(g.y,h.y),e=Math.min(g.right,h.right),a=Math.min(g.bottom,h.bottom),c=Math.max(g.x,h.x);if(a>d&&e>c){return new this.self(d,e,a,c)}else{return false}},union:function(h){var g=this,d=Math.min(g.y,h.y),e=Math.max(g.right,h.right),a=Math.max(g.bottom,h.bottom),c=Math.min(g.x,h.x);return new this.self(d,e,a,c)},constrainTo:function(b){var a=this,c=Ext.Number.constrain;a.top=a.y=c(a.top,b.y,b.bottom);a.bottom=c(a.bottom,b.y,b.bottom);a.left=a.x=c(a.left,b.x,b.right);a.right=c(a.right,b.x,b.right);return a},adjust:function(d,g,a,c){var e=this;e.top=e.y+=d;e.left=e.x+=c;e.right+=g;e.bottom+=a;return e},getOutOfBoundOffset:function(a,b){if(!Ext.isObject(a)){if(a=="x"){return this.getOutOfBoundOffsetX(b)}else{return this.getOutOfBoundOffsetY(b)}}else{b=a;var c=new Ext.util.Offset();c.x=this.getOutOfBoundOffsetX(b.x);c.y=this.getOutOfBoundOffsetY(b.y);return c}},getOutOfBoundOffsetX:function(a){if(a<=this.x){return this.x-a}else{if(a>=this.right){return this.right-a}}return 0},getOutOfBoundOffsetY:function(a){if(a<=this.y){return this.y-a}else{if(a>=this.bottom){return this.bottom-a}}return 0},isOutOfBound:function(a,b){if(!Ext.isObject(a)){if(a=="x"){return this.isOutOfBoundX(b)}else{return this.isOutOfBoundY(b)}}else{b=a;return(this.isOutOfBoundX(b.x)||this.isOutOfBoundY(b.y))}},isOutOfBoundX:function(a){return(a<this.x||a>this.right)},isOutOfBoundY:function(a){return(a<this.y||a>this.bottom)},restrict:function(b,d,a){if(Ext.isObject(b)){var c;a=d;d=b;if(d.copy){c=d.copy()}else{c={x:d.x,y:d.y}}c.x=this.restrictX(d.x,a);c.y=this.restrictY(d.y,a);return c}else{if(b=="x"){return this.restrictX(d,a)}else{return this.restrictY(d,a)}}},restrictX:function(b,a){if(!a){a=1}if(b<=this.x){b-=(b-this.x)*a}else{if(b>=this.right){b-=(b-this.right)*a}}return b},restrictY:function(b,a){if(!a){a=1}if(b<=this.y){b-=(b-this.y)*a}else{if(b>=this.bottom){b-=(b-this.bottom)*a}}return b},getSize:function(){return{width:this.right-this.x,height:this.bottom-this.y}},copy:function(){return new this.self(this.y,this.right,this.bottom,this.x)},copyFrom:function(b){var a=this;a.top=a.y=a[1]=b.y;a.right=b.right;a.bottom=b.bottom;a.left=a.x=a[0]=b.x;return this},toString:function(){return"Region["+this.top+","+this.right+","+this.bottom+","+this.left+"]"},translateBy:function(a,c){if(arguments.length==1){c=a.y;a=a.x}var b=this;b.top=b.y+=c;b.right+=a;b.bottom+=c;b.left=b.x+=a;return b},round:function(){var a=this;a.top=a.y=Math.round(a.y);a.right=Math.round(a.right);a.bottom=Math.round(a.bottom);a.left=a.x=Math.round(a.x);return a},equals:function(a){return(this.top==a.top&&this.right==a.right&&this.bottom==a.bottom&&this.left==a.left)}});Ext.define("Ext.dd.DragDropManager",{singleton:true,requires:["Ext.util.Region"],uses:["Ext.tip.QuickTipManager"],alternateClassName:["Ext.dd.DragDropMgr","Ext.dd.DDM"],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,notifyOccluded:false,_execOnAll:function(c,b){var d,a,e;for(d in this.ids){for(a in this.ids[d]){e=this.ids[d][a];if(!this.isTypeOfDD(e)){continue}e[c].apply(e,b)}}},_onLoad:function(){this.init();var a=Ext.EventManager;a.on(document,"mouseup",this.handleMouseUp,this,true);a.on(document,"mousemove",this.handleMouseMove,this,true);a.on(window,"unload",this._onUnload,this,true);a.on(window,"resize",this._onResize,this,true)},_onResize:function(a){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(b,a){if(!this.initialized){this.init()}if(!this.ids[a]){this.ids[a]={}}this.ids[a][b.id]=b},removeDDFromGroup:function(c,a){if(!this.ids[a]){this.ids[a]={}}var b=this.ids[a];if(b&&b[c.id]){delete b[c.id]}},_remove:function(b){for(var a in b.groups){if(a&&this.ids[a]&&this.ids[a][b.id]){delete this.ids[a][b.id]}}delete this.handleIds[b.id]},regHandle:function(b,a){if(!this.handleIds[b]){this.handleIds[b]={}}this.handleIds[b][a]=a},isDragDrop:function(a){return(this.getDDById(a))?true:false},getRelated:function(g,b){var e=[],d,c,a;for(d in g.groups){for(c in this.ids[d]){a=this.ids[d][c];if(!this.isTypeOfDD(a)){continue}if(!b||a.isTarget){e[e.length]=a}}}return e},isLegalTarget:function(e,d){var b=this.getRelated(e,true),c,a;for(c=0,a=b.length;c<a;++c){if(b[c].id==d.id){return true}}return false},isTypeOfDD:function(a){return(a&&a.__ygDragDrop)},isHandle:function(b,a){return(this.handleIds[b]&&this.handleIds[b][a])},getDDById:function(d){var c=this,b,a;for(b in this.ids){a=this.ids[b][d];if(a instanceof Ext.dd.DDTarget){return a}}return null},handleMouseDown:function(c,b){if(Ext.tip.QuickTipManager){Ext.tip.QuickTipManager.ddDisable()}if(this.dragCurrent){this.handleMouseUp(c)}this.currentTarget=c.getTarget();this.dragCurrent=b;var a=b.getEl();if(Ext.isIE&&a.setCapture){a.setCapture()}this.startX=c.getPageX();this.startY=c.getPageY();this.deltaX=this.startX-a.offsetLeft;this.deltaY=this.startY-a.offsetTop;this.dragThreshMet=false;this.clickTimeout=setTimeout(function(){var d=Ext.dd.DragDropManager;d.startDrag(d.startX,d.startY)},this.clickTimeThresh)},startDrag:function(a,b){clearTimeout(this.clickTimeout);if(this.dragCurrent){this.dragCurrent.b4StartDrag(a,b);this.dragCurrent.startDrag(a,b)}this.dragThreshMet=true},handleMouseUp:function(b){var a=this.dragCurrent;if(Ext.tip&&Ext.tip.QuickTipManager){Ext.tip.QuickTipManager.ddEnable()}if(!a){return}if(Ext.isIE&&document.releaseCapture){document.releaseCapture()}clearTimeout(this.clickTimeout);if(this.dragThreshMet){this.fireEvents(b,true)}this.stopDrag(b);this.stopEvent(b)},stopEvent:function(a){if(this.stopPropagation){a.stopPropagation()}if(this.preventDefault){a.preventDefault()}},stopDrag:function(a){if(this.dragCurrent){if(this.dragThreshMet){this.dragCurrent.b4EndDrag(a);this.dragCurrent.endDrag(a)}this.dragCurrent.onMouseUp(a)}this.dragCurrent=null;this.dragOvers={}},handleMouseMove:function(d){var c=this,b,a;if(!c.dragCurrent){return true}if(!c.dragThreshMet){b=Math.abs(c.startX-d.getPageX());a=Math.abs(c.startY-d.getPageY());if(b>c.clickPixelThresh||a>c.clickPixelThresh){c.startDrag(c.startX,c.startY)}}if(c.dragThreshMet){c.dragCurrent.b4Drag(d);c.dragCurrent.onDrag(d);if(!c.dragCurrent.moveOnly){c.fireEvents(d,false)}}c.stopEvent(d);return true},fireEvents:function(n,q){var p=this,k=p.dragCurrent,r=n.getPoint(),b,t,d=[],a=[],g=[],l=[],j=[],c=[],o,h,m,s;if(!k||k.isLocked()){return}for(h in p.dragOvers){b=p.dragOvers[h];if(!p.isTypeOfDD(b)){continue}if(!this.isOverTarget(r,b,p.mode)){g.push(b)}a[h]=true;delete p.dragOvers[h]}for(s in k.groups){if("string"!=typeof s){continue}for(h in p.ids[s]){b=p.ids[s][h];if(p.isTypeOfDD(b)&&(t=b.getEl())&&(b.isTarget)&&(!b.isLocked())&&(Ext.fly(t).isVisible(true))&&((b!=k)||(k.ignoreSelf===false))){if((b.zIndex=p.getZIndex(t))!==-1){o=true}d.push(b)}}}if(o){Ext.Array.sort(d,p.byZIndex)}for(h=0,m=d.length;h<m;h++){b=d[h];if(p.isOverTarget(r,b,p.mode)){if(q){j.push(b)}else{if(!a[b.id]){c.push(b)}else{l.push(b)}p.dragOvers[b.id]=b}if(!p.notifyOccluded){break}}}if(p.mode){if(g.length){k.b4DragOut(n,g);k.onDragOut(n,g)}if(c.length){k.onDragEnter(n,c)}if(l.length){k.b4DragOver(n,l);k.onDragOver(n,l)}if(j.length){k.b4DragDrop(n,j);k.onDragDrop(n,j)}}else{for(h=0,m=g.length;h<m;++h){k.b4DragOut(n,g[h].id);k.onDragOut(n,g[h].id)}for(h=0,m=c.length;h<m;++h){k.onDragEnter(n,c[h].id)}for(h=0,m=l.length;h<m;++h){k.b4DragOver(n,l[h].id);k.onDragOver(n,l[h].id)}for(h=0,m=j.length;h<m;++h){k.b4DragDrop(n,j[h].id);k.onDragDrop(n,j[h].id)}}if(q&&!j.length){k.onInvalidDrop(n)}},getZIndex:function(b){var a=document.body,c,d=-1;b=Ext.getDom(b);while(b!==a){if(!isNaN(c=Number(Ext.fly(b).getStyle("zIndex")))){d=c}b=b.parentNode}return d},byZIndex:function(b,a){return b.zIndex<a.zIndex},getBestMatch:function(c){var e=null,b=c.length,d,a;if(b==1){e=c[0]}else{for(d=0;d<b;++d){a=c[d];if(a.cursorIsOver){e=a;break}else{if(!e||e.overlap.getArea()<a.overlap.getArea()){e=a}}}}return e},refreshCache:function(b){var a,c,d,e;for(a in b){if("string"!=typeof a){continue}for(c in this.ids[a]){d=this.ids[a][c];if(this.isTypeOfDD(d)){e=this.getLocation(d);if(e){this.locationCache[d.id]=e}else{delete this.locationCache[d.id]}}}}},verifyEl:function(b){if(b){var a;if(Ext.isIE){try{a=b.offsetParent}catch(c){}}else{a=b.offsetParent}if(a){return true}}return false},getLocation:function(i){if(!this.isTypeOfDD(i)){return null}if(i.getRegion){return i.getRegion()}var g=i.getEl(),m,d,c,o,n,p,a,k,h;try{m=Ext.Element.getXY(g)}catch(j){}if(!m){return null}d=m[0];c=d+g.offsetWidth;o=m[1];n=o+g.offsetHeight;p=o-i.padding[0];a=c+i.padding[1];k=n+i.padding[2];h=d-i.padding[3];return new Ext.util.Region(p,a,k,h)},isOverTarget:function(j,a,c){var e=this.locationCache[a.id],i,g,b,d,h;if(!e||!this.useCache){e=this.getLocation(a);this.locationCache[a.id]=e}if(!e){return false}a.cursorIsOver=e.contains(j);i=this.dragCurrent;if(!i||!i.getTargetCoord||(!c&&!i.constrainX&&!i.constrainY)){return a.cursorIsOver}a.overlap=null;g=i.getTargetCoord(j.x,j.y);b=i.getDragEl();d=new Ext.util.Region(g.y,g.x+b.offsetWidth,g.y+b.offsetHeight,g.x);h=d.intersect(e);if(h){a.overlap=h;return(c)?true:a.cursorIsOver}else{return false}},_onUnload:function(b,a){Ext.dd.DragDropManager.unregAll()},unregAll:function(){if(this.dragCurrent){this.stopDrag();this.dragCurrent=null}this._execOnAll("unreg",[]);for(var a in this.elementCache){delete this.elementCache[a]}this.elementCache={};this.ids={}},elementCache:{},getElWrapper:function(b){var a=this.elementCache[b];if(!a||!a.el){a=this.elementCache[b]=new this.ElementWrapper(Ext.getDom(b))}return a},getElement:function(a){return Ext.getDom(a)},getCss:function(b){var a=Ext.getDom(b);return(a)?a.style:null},ElementWrapper:function(a){this.el=a||null;this.id=this.el&&a.id;this.css=this.el&&a.style},getPosX:function(a){return Ext.Element.getX(a)},getPosY:function(a){return Ext.Element.getY(a)},swapNode:function(c,a){if(c.swapNode){c.swapNode(a)}else{var d=a.parentNode,b=a.nextSibling;if(b==c){d.insertBefore(c,a)}else{if(a==c.nextSibling){d.insertBefore(a,c)}else{c.parentNode.replaceChild(a,c);d.insertBefore(c,b)}}}},getScroll:function(){var d=window.document,e=d.documentElement,a=d.body,c=0,b=0;if(Ext.isGecko4){c=window.scrollYOffset;b=window.scrollXOffset}else{if(e&&(e.scrollTop||e.scrollLeft)){c=e.scrollTop;b=e.scrollLeft}else{if(a){c=a.scrollTop;b=a.scrollLeft}}}return{top:c,left:b}},getStyle:function(b,a){return Ext.fly(b).getStyle(a)},getScrollTop:function(){return this.getScroll().top},getScrollLeft:function(){return this.getScroll().left},moveToEl:function(a,c){var b=Ext.Element.getXY(c);Ext.Element.setXY(a,b)},numericSort:function(d,c){return(d-c)},_timeoutCount:0,_addListeners:function(){if(document){this._onLoad()}else{if(this._timeoutCount<=2000){setTimeout(this._addListeners,10);if(document&&document.body){this._timeoutCount+=1}}}},handleWasClicked:function(a,c){if(this.isHandle(c,a.id)){return true}else{var b=a.parentNode;while(b){if(this.isHandle(c,b.id)){return true}else{b=b.parentNode}}}return false}},function(){this._addListeners()});Ext.define("Ext.layout.container.Box",{alias:["layout.box"],extend:"Ext.layout.container.Container",alternateClassName:"Ext.layout.BoxLayout",requires:["Ext.layout.container.boxOverflow.None","Ext.layout.container.boxOverflow.Menu","Ext.layout.container.boxOverflow.Scroller","Ext.util.Format","Ext.dd.DragDropManager"],defaultMargins:{top:0,right:0,bottom:0,left:0},padding:0,pack:"start",flex:undefined,stretchMaxPartner:undefined,type:"box",scrollOffset:0,itemCls:Ext.baseCSSPrefix+"box-item",targetCls:Ext.baseCSSPrefix+"box-layout-ct",innerCls:Ext.baseCSSPrefix+"box-inner",availableSpaceOffset:0,reserveOffset:true,manageMargins:true,childEls:["innerCt","targetEl"],renderTpl:["{%var oc,l=values.$comp.layout,oh=l.overflowHandler;","if (oh.getPrefixConfig!==Ext.emptyFn) {","if(oc=oh.getPrefixConfig())dh.generateMarkup(oc, out)","}%}",'<div id="{ownerId}-innerCt" class="{[l.innerCls]} {[oh.getOverflowCls()]}" role="presentation">','<div id="{ownerId}-targetEl" style="position:absolute;',"width:20000px;","left:0px;top:0px;",'height:1px">',"{%this.renderBody(out, values)%}","</div>","</div>","{%if (oh.getSuffixConfig!==Ext.emptyFn) {","if(oc=oh.getSuffixConfig())dh.generateMarkup(oc, out)","}%}",{disableFormats:true,definitions:"var dh=Ext.DomHelper;"}],constructor:function(a){var c=this,b;c.callParent(arguments);c.flexSortFn=Ext.Function.bind(c.flexSort,c);c.initOverflowHandler();b=typeof c.padding;if(b=="string"||b=="number"){c.padding=Ext.util.Format.parseBox(c.padding);c.padding.height=c.padding.top+c.padding.bottom;c.padding.width=c.padding.left+c.padding.right}},getNames:function(){return this.names},_percentageRe:/^\s*(\d+(?:\.\d*)?)\s*[%]\s*$/,getItemSizePolicy:function(m,n){var j=this,h=j.sizePolicy,g=j.align,e=m.flex,k=g,i=j.names,a=m[i.width],l=m[i.height],c=j._percentageRe,b=c.test(a),d=(g=="stretch");if((d||e||b)&&!n){n=j.owner.getSizeModel()}if(d){if(!c.test(l)&&n[i.height].shrinkWrap){k="stretchmax"}}else{if(g!="stretchmax"){if(c.test(l)){k="stretch"}else{k=""}}}if(e||b){if(!n[i.width].shrinkWrap){h=h.flex}}return h[k]},flexSort:function(d,c){var e=this.getNames().maxWidth,g=Infinity;d=d.target[e]||g;c=c.target[e]||g;if(!isFinite(d)&&!isFinite(c)){return 0}return d-c},isItemBoxParent:function(a){return true},isItemShrinkWrap:function(a){return true},minSizeSortFn:function(d,c){return c.available-d.available},roundFlex:function(a){return Math.ceil(a)},beginCollapse:function(b){var a=this;if(a.direction==="vertical"&&b.collapsedVertical()){b.collapseMemento.capture(["flex"]);delete b.flex}else{if(a.direction==="horizontal"&&b.collapsedHorizontal()){b.collapseMemento.capture(["flex"]);delete b.flex}}},beginExpand:function(a){a.collapseMemento.restore(["flex"])},beginLayout:function(c){var b=this,e=b.owner.stretchMaxPartner,a=b.innerCt.dom.style,d=b.getNames();c.boxNames=d;b.overflowHandler.beginLayout(c);if(typeof e==="string"){e=Ext.getCmp(e)||b.owner.query(e)[0]}c.stretchMaxPartner=e&&c.context.getCmp(e);b.callParent(arguments);c.innerCtContext=c.getEl("innerCt",b);b.scrollParallel=!!(b.owner.autoScroll||b.owner[d.overflowX]);b.scrollPerpendicular=!!(b.owner.autoScroll||b.owner[d.overflowY]);if(b.scrollParallel){b.scrollPos=b.owner.getTargetEl().dom[d.scrollLeft]}a.width="";a.height=""},beginLayoutCycle:function(e,a){var d=this,h=d.align,g=e.boxNames,b=d.pack,c=g.heightModel;d.overflowHandler.beginLayoutCycle(e,a);d.callParent(arguments);e.parallelSizeModel=e[g.widthModel];e.perpendicularSizeModel=e[c];e.boxOptions={align:h={stretch:h=="stretch",stretchmax:h=="stretchmax",center:h==g.center},pack:b={center:b=="center",end:b=="end"}};if(h.stretch&&e.perpendicularSizeModel.shrinkWrap){h.stretchmax=true;h.stretch=false}h.nostretch=!(h.stretch||h.stretchmax);if(e.parallelSizeModel.shrinkWrap){b.center=b.end=false}d.cacheFlexes(e);if(Ext.isWebKit){d.targetEl.setWidth(20000)}},cacheFlexes:function(k){var u=this,l=k.boxNames,a=l.widthModel,d=l.heightModel,c=k.boxOptions.align.nostretch,o=0,b=k.childItems,q=b.length,s=[],m=0,j=l.minWidth,g=u._percentageRe,r=0,t=0,e,n,p,h;while(q--){n=b[q];e=n.target;if(n[a].calculated){n.flex=p=e.flex;if(p){o+=p;s.push(n);m+=e[j]||0}else{h=g.exec(e[l.width]);n.percentageParallel=parseFloat(h[1])/100;++r}}if(c&&n[d].calculated){h=g.exec(e[l.height]);n.percentagePerpendicular=parseFloat(h[1])/100;++t}}k.flexedItems=s;k.flexedMinSize=m;k.totalFlex=o;k.percentageWidths=r;k.percentageHeights=t;Ext.Array.sort(s,u.flexSortFn)},calculate:function(d){var b=this,a=b.getContainerSize(d),g=d.boxNames,c=d.state,e=c.boxPlan||(c.boxPlan={});e.targetSize=a;if(!d.parallelSizeModel.shrinkWrap&&!a[g.gotWidth]){b.done=false;return}if(!c.parallelDone){c.parallelDone=b.calculateParallel(d,g,e)}if(!c.perpendicularDone){c.perpendicularDone=b.calculatePerpendicular(d,g,e)}if(c.parallelDone&&c.perpendicularDone){if(b.owner.dock&&(Ext.isIE6||Ext.isIE7||Ext.isIEQuirks)&&!b.owner.width&&!b.horizontal){e.isIEVerticalDock=true;e.calculatedWidth=e.maxSize+d.getPaddingInfo().width+d.getFrameInfo().width}b.publishInnerCtSize(d,b.reserveOffset?b.availableSpaceOffset:0);if(b.done&&d.childItems.length>1&&d.boxOptions.align.stretchmax&&!c.stretchMaxDone){b.calculateStretchMax(d,g,e);c.stretchMaxDone=true}}else{b.done=false}},calculateParallel:function(k,n,b){var F=this,z=n.width,a=k.childItems,d=n.left,r=n.right,q=n.setWidth,A=a.length,x=k.flexedItems,s=x.length,v=k.boxOptions.pack,m=F.padding,h=b.targetSize[z],B=0,e=m[d],E=e+m[r]+F.scrollOffset+(F.reserveOffset?F.availableSpaceOffset:0),w=Ext.getScrollbarSize()[n.width],u,l,g,y,o,t,D,p,C,c,j;if(w&&F.scrollPerpendicular&&k.parallelSizeModel.shrinkWrap&&!k.boxOptions.align.stretch&&!k.perpendicularSizeModel.shrinkWrap){if(!k.state.perpendicularDone){return false}C=true}for(u=0;u<A;++u){o=a[u];l=o.marginInfo||o.getMarginInfo();B+=l[z];if(!o[n.widthModel].calculated){c=o.getProp(z);E+=c;if(isNaN(E)){return false}}}E+=B;if(k.percentageWidths){j=h-B;if(isNaN(j)){return false}for(u=0;u<A;++u){o=a[u];if(o.percentageParallel){c=Math.ceil(j*o.percentageParallel);c=o.setWidth(c);E+=c}}}if(k.parallelSizeModel.shrinkWrap){b.availableSpace=0;b.tooNarrow=false}else{b.availableSpace=h-E;b.tooNarrow=b.availableSpace<k.flexedMinSize;if(b.tooNarrow&&Ext.getScrollbarSize()[n.height]&&F.scrollParallel&&k.state.perpendicularDone){k.state.perpendicularDone=false;for(u=0;u<A;++u){a[u].invalidate()}}}p=E;g=b.availableSpace;y=k.totalFlex;for(u=0;u<s;u++){o=x[u];t=o.flex;D=F.roundFlex((t/y)*g);D=o[q](D);p+=D;g=Math.max(0,g-D);y-=t}if(v.center){e+=g/2;if(e<0){e=0}}else{if(v.end){e+=g}}for(u=0;u<A;++u){o=a[u];l=o.marginInfo;e+=l[d];o.setProp(n.x,e);e+=l[r]+o.props[z]}p+=k.targetContext.getPaddingInfo()[z];k.state.contentWidth=p;if(C&&(k.peek(n.contentHeight)>b.targetSize[n.height])){p+=w;k[n.hasOverflowY]=true;k.target.componentLayout[n.setWidthInDom]=true;k[n.invalidateScrollY]=(Ext.isStrict&&Ext.isIE8)}k[n.setContentWidth](p);return true},calculatePerpendicular:function(r,v,c){var G=this,a=r.perpendicularSizeModel.shrinkWrap,d=c.targetSize,b=r.childItems,E=b.length,J=Math.max,H=v.height,m=v.setHeight,p=v.top,F=v.y,u=G.padding,w=u[p],h=d[H]-w-u[v.bottom],B=r.boxOptions.align,o=B.stretch,z=B.stretchmax,n=B.center,A=0,g=0,l=Ext.getScrollbarSize().height,I,C,e,t,s,y,x,k,j,q,D;if(o||(n&&!a)){if(isNaN(h)){return false}}if(G.scrollParallel&&c.tooNarrow){if(a){q=true}else{h-=l;c.targetSize[H]-=l}}if(o){y=h}else{for(C=0;C<E;C++){x=b[C];t=(x.marginInfo||x.getMarginInfo())[H];if(!(D=x.percentagePerpendicular)){e=x.getProp(H)}else{++g;if(a){continue}else{e=D*h-t;e=x[v.setHeight](e)}}if(isNaN(A=J(A,e+t,x.target[v.minHeight]||0))){return false}}if(q){A+=l;r[v.hasOverflowX]=true;r.target.componentLayout[v.setHeightInDom]=true;r[v.invalidateScrollX]=(Ext.isStrict&&Ext.isIE8)}k=r.stretchMaxPartner;if(k){r.setProp("maxChildHeight",A);j=k.childItems;if(j&&j.length){A=J(A,k.getProp("maxChildHeight"));if(isNaN(A)){return false}}}r[v.setContentHeight](A+G.padding[H]+r.targetContext.getPaddingInfo()[H]);if(q){A-=l}c.maxSize=A;if(z){y=A}else{if(n||g){y=a?A:J(h,A);y-=r.innerCtContext.getBorderInfo()[H]}}}for(C=0;C<E;C++){x=b[C];t=x.marginInfo||x.getMarginInfo();I=w+t[p];if(o){x[m](y-t[H])}else{D=x.percentagePerpendicular;if(a&&D){t=x.marginInfo||x.getMarginInfo();e=D*y-t[H];e=x.setHeight(e)}if(n){s=y-x.props[H];if(s>0){I=w+Math.round(s/2)}}}x.setProp(F,I)}return true},calculateStretchMax:function(d,k,m){var l=this,h=k.height,n=k.width,g=d.childItems,b=g.length,o=m.maxSize,a=l.onBeforeInvalidateChild,q=l.onAfterInvalidateChild,p,j,e,c;for(e=0;e<b;++e){p=g[e];j=p.props;c=o-p.getMarginInfo()[h];if(c!=j[h]||p[k.heightModel].constrained){p.invalidate({before:a,after:q,layout:l,childWidth:j[n],childHeight:c,childX:j.x,childY:j.y,names:k})}}},completeLayout:function(b){var j=this,i=b.boxNames,h=b.invalidateScrollX,g=b.invalidateScrollY,d,a,e,c,k;j.overflowHandler.completeLayout(b);if(h||g){a=j.getTarget();d=a.dom;k=d.style;if(h){e=a.getStyle("overflowX");if(e=="auto"){e=k.overflowX;k.overflowX="scroll"}else{h=false}}if(g){c=a.getStyle("overflowY");if(c=="auto"){c=k.overflowY;k.overflowY="scroll"}else{g=false}}if(h||g){d.scrollWidth;if(h){k.overflowX=e}if(g){k.overflowY=c}}}if(j.scrollParallel){j.owner.getTargetEl().dom[i.scrollLeft]=j.scrollPos}},finishedLayout:function(a){this.overflowHandler.finishedLayout(a);this.callParent(arguments);if(Ext.isWebKit){this.targetEl.setWidth(a.innerCtContext.props.width)}},onBeforeInvalidateChild:function(b,a){var c=a.names.heightModel;if(!b[c].constrainedMax){b[c]=Ext.layout.SizeModel.calculated}},onAfterInvalidateChild:function(d,c){var g=c.names,e=Ext.getScrollbarSize(),a=c.childHeight,b=c.childWidth;d.setProp("x",c.childX);d.setProp("y",c.childY);if(d[g.heightModel].calculated){d[g.setHeight](a)}if(d[g.widthModel].calculated){d[g.setWidth](b)}},publishInnerCtSize:function(a,d){var i=this,h=a.boxNames,g=h.height,k=h.width,e=a.boxOptions.align,o=i.owner.dock,l=i.padding,j=a.state.boxPlan,c=j.targetSize,n=c[g],p=a.innerCtContext,b=(a.parallelSizeModel.shrinkWrap||(j.tooNarrow&&i.scrollParallel)?a.state.contentWidth:c[k])-(d||0),m;if(e.stretch){m=n}else{m=j.maxSize+l[h.top]+l[h.bottom]+p.getBorderInfo()[g];if(!a.perpendicularSizeModel.shrinkWrap&&e.center){m=Math.max(n,m)}}p[h.setWidth](b);p[h.setHeight](m);if(isNaN(b+m)){i.done=false}if(j.calculatedWidth&&(o=="left"||o=="right")){a.setWidth(j.calculatedWidth,true,true)}},onRemove:function(a){var b=this;b.callParent(arguments);if(b.overflowHandler){b.overflowHandler.onRemove(a)}if(a.layoutMarginCap==b.id){delete a.layoutMarginCap}},initOverflowHandler:function(){var d=this,c=d.overflowHandler,b,a;if(typeof c=="string"){c={type:c}}b="None";if(c&&c.type!==undefined){b=c.type}a=Ext.layout.container.boxOverflow[b];if(a[d.type]){a=a[d.type]}d.overflowHandler=Ext.create("Ext.layout.container.boxOverflow."+b,d,c)},getRenderTarget:function(){return this.targetEl},getElementTarget:function(){return this.innerCt},destroy:function(){Ext.destroy(this.innerCt,this.overflowHandler);this.callParent(arguments)}});Ext.define("Ext.layout.container.HBox",{alias:["layout.hbox"],extend:"Ext.layout.container.Box",alternateClassName:"Ext.layout.HBoxLayout",align:"top",type:"hbox",direction:"horizontal",horizontal:true,names:{lr:"lr",left:"left",leftCap:"Left",right:"right",position:"left",width:"width",contentWidth:"contentWidth",minWidth:"minWidth",maxWidth:"maxWidth",widthCap:"Width",widthModel:"widthModel",widthIndex:0,x:"x",scrollLeft:"scrollLeft",overflowX:"overflowX",hasOverflowX:"hasOverflowX",invalidateScrollX:"invalidateScrollX",center:"middle",top:"top",topPosition:"top",bottom:"bottom",height:"height",contentHeight:"contentHeight",minHeight:"minHeight",maxHeight:"maxHeight",heightCap:"Height",heightModel:"heightModel",heightIndex:1,y:"y",scrollTop:"scrollTop",overflowY:"overflowY",hasOverflowY:"hasOverflowY",invalidateScrollY:"invalidateScrollY",getWidth:"getWidth",getHeight:"getHeight",setWidth:"setWidth",setHeight:"setHeight",gotWidth:"gotWidth",gotHeight:"gotHeight",setContentWidth:"setContentWidth",setContentHeight:"setContentHeight",setWidthInDom:"setWidthInDom",setHeightInDom:"setHeightInDom"},sizePolicy:{flex:{"":{setsWidth:1,setsHeight:0},stretch:{setsWidth:1,setsHeight:1},stretchmax:{readsHeight:1,setsWidth:1,setsHeight:1}},"":{setsWidth:0,setsHeight:0},stretch:{setsWidth:0,setsHeight:1},stretchmax:{readsHeight:1,setsWidth:0,setsHeight:1}}});Ext.define("Ext.layout.container.VBox",{alias:["layout.vbox"],extend:"Ext.layout.container.Box",alternateClassName:"Ext.layout.VBoxLayout",align:"left",type:"vbox",direction:"vertical",horizontal:false,names:{lr:"tb",left:"top",leftCap:"Top",right:"bottom",position:"top",width:"height",contentWidth:"contentHeight",minWidth:"minHeight",maxWidth:"maxHeight",widthCap:"Height",widthModel:"heightModel",widthIndex:1,x:"y",scrollLeft:"scrollTop",overflowX:"overflowY",hasOverflowX:"hasOverflowY",invalidateScrollX:"invalidateScrollY",center:"center",top:"left",topPosition:"left",bottom:"right",height:"width",contentHeight:"contentWidth",minHeight:"minWidth",maxHeight:"maxWidth",heightCap:"Width",heightModel:"widthModel",heightIndex:0,y:"x",scrollTop:"scrollLeft",overflowY:"overflowX",hasOverflowY:"hasOverflowX",invalidateScrollY:"invalidateScrollX",getWidth:"getHeight",getHeight:"getWidth",setWidth:"setHeight",setHeight:"setWidth",gotWidth:"gotHeight",gotHeight:"gotWidth",setContentWidth:"setContentHeight",setContentHeight:"setContentWidth",setWidthInDom:"setHeightInDom",setHeightInDom:"setWidthInDom"},sizePolicy:{flex:{"":{setsWidth:0,setsHeight:1},stretch:{setsWidth:1,setsHeight:1},stretchmax:{readsWidth:1,setsWidth:1,setsHeight:1}},"":{setsWidth:0,setsHeight:0},stretch:{setsWidth:1,setsHeight:0},stretchmax:{readsWidth:1,setsWidth:1,setsHeight:0}}});Ext.define("Ext.toolbar.Toolbar",{extend:"Ext.container.Container",requires:["Ext.toolbar.Fill","Ext.layout.container.HBox","Ext.layout.container.VBox"],uses:["Ext.toolbar.Separator"],alias:"widget.toolbar",alternateClassName:"Ext.Toolbar",isToolbar:true,baseCls:Ext.baseCSSPrefix+"toolbar",ariaRole:"toolbar",defaultType:"button",vertical:false,enableOverflow:false,menuTriggerCls:Ext.baseCSSPrefix+"toolbar-more-icon",trackMenus:true,itemCls:Ext.baseCSSPrefix+"toolbar-item",statics:{shortcuts:{"-":"tbseparator"," ":"tbspacer"},shortcutsHV:{0:{"->":{xtype:"tbfill",height:0}},1:{"->":{xtype:"tbfill",width:0}}}},initComponent:function(){var b=this,a;if(!b.layout&&b.enableOverflow){b.layout={overflowHandler:"Menu"}}if(b.dock==="right"||b.dock==="left"){b.vertical=true}b.layout=Ext.applyIf(Ext.isString(b.layout)?{type:b.layout}:b.layout||{},{type:b.vertical?"vbox":"hbox",align:b.vertical?"stretchmax":"middle"});if(b.vertical){b.addClsWithUI("vertical")}if(b.ui==="footer"){b.ignoreBorderManagement=true}b.callParent();b.addEvents("overflowchange")},getRefItems:function(a){var e=this,b=e.callParent(arguments),d=e.layout,c;if(a&&e.enableOverflow){c=d.overflowHandler;if(c&&c.menu){b=b.concat(c.menu.getRefItems(a))}}return b},lookupComponent:function(d){if(typeof d=="string"){var b=Ext.toolbar.Toolbar,a=b.shortcutsHV[this.vertical?1:0][d]||b.shortcuts[d];if(typeof a=="string"){d={xtype:a}}else{if(a){d=Ext.apply({},a)}else{d={xtype:"tbtext",text:d}}}this.applyDefaults(d)}return this.callParent(arguments)},applyDefaults:function(a){if(!Ext.isString(a)){a=this.callParent(arguments)}return a},trackMenu:function(c,a){if(this.trackMenus&&c.menu){var d=a?"mun":"mon",b=this;b[d](c,"mouseover",b.onButtonOver,b);b[d](c,"menushow",b.onButtonMenuShow,b);b[d](c,"menuhide",b.onButtonMenuHide,b)}},constructButton:function(a){return a.events?a:Ext.widget(a.split?"splitbutton":this.defaultType,a)},onBeforeAdd:function(a){if(a.is("field")||(a.is("button")&&this.ui!="footer")){a.ui=a.ui+"-toolbar"}if(a instanceof Ext.toolbar.Separator){a.setUI((this.vertical)?"vertical":"horizontal")}this.callParent(arguments)},onAdd:function(a){this.callParent(arguments);this.trackMenu(a)},onRemove:function(a){this.callParent(arguments);this.trackMenu(a,true)},getChildItemsToDisable:function(){return this.items.getRange()},onButtonOver:function(a){if(this.activeMenuBtn&&this.activeMenuBtn!=a){this.activeMenuBtn.hideMenu();a.showMenu();this.activeMenuBtn=a}},onButtonMenuShow:function(a){this.activeMenuBtn=a},onButtonMenuHide:function(a){delete this.activeMenuBtn}});Ext.define("Ext.container.DockingContainer",{requires:["Ext.util.MixedCollection","Ext.Element"],isDockingContainer:true,defaultDockWeights:{top:{render:1,visual:1},left:{render:3,visual:5},right:{render:5,visual:7},bottom:{render:7,visual:3}},dockOrder:{top:-1,left:-1,right:1,bottom:1},addDocked:function(a,g){var e=this,b=0,d,c;a=e.prepareItems(a);c=a.length;for(;b<c;b++){d=a[b];d.dock=d.dock||"top";if(g!==undefined){e.dockedItems.insert(g+b,d)}else{e.dockedItems.add(d)}if(d.onAdded!==Ext.emptyFn){d.onAdded(e,b)}if(e.onDockedAdd!==Ext.emptyFn){e.onDockedAdd(d)}}if(e.rendered&&!e.suspendLayout){e.updateLayout()}return a},destroyDockedItems:function(){var a=this.dockedItems,b;if(a){while((b=a.first())){this.removeDocked(b,true)}}},doRenderDockedItems:function(c,g,h){var e=g.$comp,d=e.componentLayout,b,a;if(d.getDockedItems&&!g.$skipDockedItems){b=d.getDockedItems("render",!h);a=b&&d.getItemsRenderTree(b);if(a){Ext.DomHelper.generateMarkup(a,c)}}},getDockedComponent:function(a){if(Ext.isObject(a)){a=a.getItemId()}return this.dockedItems.get(a)},getDockedItems:function(a,c){var b=this.getComponentLayout().getDockedItems("render",c);if(a&&b.length){b=Ext.ComponentQuery.query(a,b)}return b},getDockingRefItems:function(b,e){var a=b&&"*,* *",d=this.getDockedItems(a,true),c;d.push.apply(d,e);c=this.getDockedItems(a,false);d.push.apply(d,c);return d},initDockingItems:function(){var b=this,a=b.dockedItems;b.dockedItems=new Ext.util.AbstractMixedCollection(false,b.getComponentId);if(a){b.addDocked(a)}},insertDocked:function(b,a){this.addDocked(a,b)},onDockedAdd:Ext.emptyFn,onDockedRemove:Ext.emptyFn,removeDocked:function(e,b){var d=this,c,a;if(!d.dockedItems.contains(e)){return e}c=d.componentLayout;a=c&&d.rendered;if(a){c.onRemove(e)}d.dockedItems.remove(e);e.onRemoved();d.onDockedRemove(e);if(b===true||(b!==false&&d.autoDestroy)){e.destroy()}else{if(a){c.afterRemove(e)}}if(!d.destroying&&!d.suspendLayout){d.updateLayout()}return e},setupDockingRenderTpl:function(a){a.renderDockedItems=this.doRenderDockedItems}});Ext.define("Ext.panel.AbstractPanel",{extend:"Ext.container.Container",mixins:{docking:"Ext.container.DockingContainer"},requires:["Ext.util.MixedCollection","Ext.Element","Ext.toolbar.Toolbar"],baseCls:Ext.baseCSSPrefix+"panel",isPanel:true,componentLayout:"dock",childEls:["body"],renderTpl:["{% this.renderDockedItems(out,values,0); %}",(Ext.isIE6||Ext.isIE7||Ext.isIEQuirks)?"<div></div>":"",'<div id="{id}-body" class="{baseCls}-body<tpl if="bodyCls"> {bodyCls}</tpl>',' {baseCls}-body-{ui}<tpl if="uiCls">','<tpl for="uiCls"> {parent.baseCls}-body-{parent.ui}-{.}</tpl>','</tpl>"<tpl if="bodyStyle"> style="{bodyStyle}"</tpl>>',"{%this.renderContainer(out,values);%}","</div>","{% this.renderDockedItems(out,values,1); %}"],bodyPosProps:{x:"x",y:"y"},border:true,emptyArray:[],initComponent:function(){var a=this;if(a.frame&&a.border&&a.bodyBorder===undefined){a.bodyBorder=false}if(a.frame&&a.border&&(a.bodyBorder===false||a.bodyBorder===0)){a.manageBodyBorders=true}a.callParent()},beforeDestroy:function(){this.destroyDockedItems();this.callParent()},initItems:function(){this.callParent();this.initDockingItems()},initRenderData:function(){var a=this,b=a.callParent();a.initBodyStyles();a.protoBody.writeTo(b);delete a.protoBody;return b},getComponent:function(a){var b=this.callParent(arguments);if(b===undefined&&!Ext.isNumber(a)){b=this.getDockedComponent(a)}return b},getProtoBody:function(){var b=this,a=b.protoBody;if(!a){b.protoBody=a=new Ext.util.ProtoElement({cls:b.bodyCls,style:b.bodyStyle,clsProp:"bodyCls",styleProp:"bodyStyle",styleIsText:true})}return a},initBodyStyles:function(){var c=this,a=c.getProtoBody(),b=Ext.Element;if(c.bodyPadding!==undefined){a.setStyle("padding",b.unitizeBox((c.bodyPadding===true)?5:c.bodyPadding))}if(c.frame&&c.bodyBorder){if(!Ext.isNumber(c.bodyBorder)){c.bodyBorder=1}a.setStyle("border-width",b.unitizeBox(c.bodyBorder))}},getCollapsedDockedItems:function(){var a=this;return a.collapseMode=="placeholder"?a.emptyArray:[a.getReExpander()]},setBodyStyle:function(b,d){var c=this,a=c.rendered?c.body:c.getProtoBody();if(Ext.isFunction(b)){b=b()}if(arguments.length==1){if(Ext.isString(b)){b=Ext.Element.parseStyles(b)}a.setStyle(b)}else{a.setStyle(b,d)}return c},addBodyCls:function(b){var c=this,a=c.rendered?c.body:c.getProtoBody();a.addCls(b);return c},removeBodyCls:function(b){var c=this,a=c.rendered?c.body:c.getProtoBody();a.removeCls(b);return c},addUIClsToElement:function(b){var c=this,a=c.callParent(arguments);c.addBodyCls([Ext.baseCSSPrefix+b,c.baseCls+"-body-"+b,c.baseCls+"-body-"+c.ui+"-"+b]);return a},removeUIClsFromElement:function(b){var c=this,a=c.callParent(arguments);c.removeBodyCls([Ext.baseCSSPrefix+b,c.baseCls+"-body-"+b,c.baseCls+"-body-"+c.ui+"-"+b]);return a},addUIToElement:function(){var a=this;a.callParent(arguments);a.addBodyCls(a.baseCls+"-body-"+a.ui)},removeUIFromElement:function(){var a=this;a.callParent(arguments);a.removeBodyCls(a.baseCls+"-body-"+a.ui)},getTargetEl:function(){return this.body},getRefItems:function(a){var b=this.callParent(arguments);return this.getDockingRefItems(a,b)},setupRenderTpl:function(a){this.callParent(arguments);this.setupDockingRenderTpl(a)}});Ext.define("Ext.layout.component.Body",{alias:["layout.body"],extend:"Ext.layout.component.Auto",type:"body",beginLayout:function(a){this.callParent(arguments);a.bodyContext=a.getEl("body")},calculateOwnerHeightFromContentHeight:function(c,b){var a=this.callParent(arguments);if(c.targetContext!=c){a+=c.getPaddingInfo().height}return a},calculateOwnerWidthFromContentWidth:function(c,a){var b=this.callParent(arguments);if(c.targetContext!=c){b+=c.getPaddingInfo().width}return b},measureContentWidth:function(a){return a.bodyContext.setWidth(a.bodyContext.el.dom.offsetWidth,false)},measureContentHeight:function(a){return a.bodyContext.setHeight(a.bodyContext.el.dom.offsetHeight,false)},publishInnerHeight:function(c,a){var d=a-c.getFrameInfo().height,b=c.targetContext;if(b!=c){d-=c.getPaddingInfo().height}return c.bodyContext.setHeight(d,!c.heightModel.natural)},publishInnerWidth:function(d,c){var a=c-d.getFrameInfo().width,b=d.targetContext;if(b!=d){a-=d.getPaddingInfo().width}d.bodyContext.setWidth(a,!d.widthModel.natural)}});Ext.define("Ext.panel.Header",{extend:"Ext.container.Container",uses:["Ext.panel.Tool","Ext.draw.Component","Ext.util.CSS","Ext.layout.component.Body","Ext.Img"],alias:"widget.header",isHeader:true,defaultType:"tool",indicateDrag:false,weight:-1,componentLayout:"body",titleAlign:"left",childEls:["body"],renderTpl:['<div id="{id}-body" class="{baseCls}-body {bodyCls}','<tpl for="uiCls"> {parent.baseCls}-body-{parent.ui}-{.}</tpl>"','<tpl if="bodyStyle"> style="{bodyStyle}"</tpl>>',"{%this.renderContainer(out,values)%}","</div>"],headingTpl:'<span id="{id}-textEl" class="{cls}-text {cls}-text-{ui}">{title}</span>',shrinkWrap:3,initComponent:function(){var b=this,e,d,a,c,g;b.addEvents("click","dblclick");b.indicateDragCls=b.baseCls+"-draggable";b.title=b.title||"&#160;";b.tools=b.tools||[];b.items=b.items||[];b.orientation=b.orientation||"horizontal";b.dock=(b.dock)?b.dock:(b.orientation=="horizontal")?"top":"left";b.addClsWithUI([b.orientation,b.dock]);if(b.indicateDrag){b.addCls(b.indicateDragCls)}if(!Ext.isEmpty(b.iconCls)||!Ext.isEmpty(b.icon)){b.initIconCmp();b.items.push(b.iconCmp)}if(b.orientation=="vertical"){b.layout={type:"vbox",align:"center"};b.textConfig={width:16,cls:b.baseCls+"-text",type:"text",text:b.title,rotate:{degrees:90}};c=b.ui;if(Ext.isArray(c)){c=c[0]}e="."+b.baseCls+"-text-"+c;if(Ext.scopeResetCSS){e="."+Ext.baseCSSPrefix+"reset "+e}d=Ext.util.CSS.getRule(e);if(d){a=d.style}else{a=(g=Ext.resetElement.createChild({style:"position:absolute",cls:b.baseCls+"-text-"+c})).getStyles("fontFamily","fontWeight","fontSize","color");g.remove()}if(a){Ext.apply(b.textConfig,{"font-family":a.fontFamily,"font-weight":a.fontWeight,"font-size":a.fontSize,fill:a.color})}b.titleCmp=new Ext.draw.Component({width:16,ariaRole:"heading",focusable:false,viewBox:false,flex:1,id:b.id+"_hd",autoSize:true,items:b.textConfig,xhooks:{setSize:function(h){this.callParent([h])}},childEls:[{name:"textEl",select:"."+b.baseCls+"-text"}]})}else{b.layout={type:"hbox",align:"middle"};b.titleCmp=new Ext.Component({ariaRole:"heading",focusable:false,noWrap:true,flex:1,id:b.id+"_hd",style:"text-align:"+b.titleAlign,cls:b.baseCls+"-text-container",renderTpl:b.getTpl("headingTpl"),renderData:{title:b.title,cls:b.baseCls,ui:b.ui},childEls:["textEl"]})}b.items.push(b.titleCmp);b.items=b.items.concat(b.tools);b.callParent();b.on({dblclick:b.onDblClick,click:b.onClick,element:"el",scope:b})},initIconCmp:function(){var b=this,a={focusable:false,src:Ext.BLANK_IMAGE_URL,cls:[b.baseCls+"-icon",b.iconCls],id:b.id+"-iconEl",iconCls:b.iconCls};if(!Ext.isEmpty(b.icon)){delete a.iconCls;a.src=b.icon}b.iconCmp=new Ext.Img(a)},afterRender:function(){this.el.unselectable();this.callParent()},addUIClsToElement:function(b){var e=this,a=e.callParent(arguments),d=[e.baseCls+"-body-"+b,e.baseCls+"-body-"+e.ui+"-"+b],g,c;if(e.bodyCls){g=e.bodyCls.split(" ");for(c=0;c<d.length;c++){if(!Ext.Array.contains(g,d[c])){g.push(d[c])}}e.bodyCls=g.join(" ")}else{e.bodyCls=d.join(" ")}return a},removeUIClsFromElement:function(b){var e=this,a=e.callParent(arguments),d=[e.baseCls+"-body-"+b,e.baseCls+"-body-"+e.ui+"-"+b],g,c;if(e.bodyCls){g=e.bodyCls.split(" ");for(c=0;c<d.length;c++){Ext.Array.remove(g,d[c])}e.bodyCls=g.join(" ")}return a},addUIToElement:function(){var b=this,c,a;b.callParent(arguments);a=b.baseCls+"-body-"+b.ui;if(b.rendered){if(b.bodyCls){b.body.addCls(b.bodyCls)}else{b.body.addCls(a)}}else{if(b.bodyCls){c=b.bodyCls.split(" ");if(!Ext.Array.contains(c,a)){c.push(a)}b.bodyCls=c.join(" ")}else{b.bodyCls=a}}if(b.titleCmp&&b.titleCmp.rendered&&b.titleCmp.textEl){b.titleCmp.textEl.addCls(b.baseCls+"-text-"+b.ui)}},removeUIFromElement:function(){var b=this,c,a;b.callParent(arguments);a=b.baseCls+"-body-"+b.ui;if(b.rendered){if(b.bodyCls){b.body.removeCls(b.bodyCls)}else{b.body.removeCls(a)}}else{if(b.bodyCls){c=b.bodyCls.split(" ");Ext.Array.remove(c,a);b.bodyCls=c.join(" ")}else{b.bodyCls=a}}if(b.titleCmp&&b.titleCmp.rendered&&b.titleCmp.textEl){b.titleCmp.textEl.removeCls(b.baseCls+"-text-"+b.ui)}},onClick:function(a){this.fireClickEvent("click",a)},onDblClick:function(a){this.fireClickEvent("dblclick",a)},fireClickEvent:function(a,c){var b="."+Ext.panel.Tool.prototype.baseCls;if(!c.getTarget(b)){this.fireEvent(a,this,c)}},getFocusEl:function(){return this.el},getTargetEl:function(){return this.body||this.frameBody||this.el},setTitle:function(d){var c=this,b,a;if(c.rendered){if(c.titleCmp.rendered){if(c.titleCmp.surface){c.title=d||"";b=c.titleCmp.surface.items.items[0];a=c.titleCmp.surface;a.remove(b);c.textConfig.type="text";c.textConfig.text=d;b=a.add(c.textConfig);b.setAttributes({rotate:{degrees:90}},true);c.titleCmp.autoSizeSurface()}else{c.title=d;c.titleCmp.textEl.update(c.title||"&#160;")}c.titleCmp.updateLayout()}else{c.titleCmp.on({render:function(){c.setTitle(d)},single:true})}}else{c.title=d}},getMinWidth:function(){var e=this,d=e.titleCmp.textEl.dom,a,g=e.tools,b,c;d.style.display="inline";a=d.offsetWidth;d.style.display="";if(g&&(b=g.length)){for(c=0;c<b;c++){if(g[c].el){a+=g[c].el.dom.offsetWidth}}}if(e.iconCmp){a+=e.iconCmp.el.dom.offsetWidth}return a+10},setIconCls:function(a){var b=this,d=!a||!a.length,c=b.iconCmp;b.iconCls=a;if(!b.iconCmp&&!d){b.initIconCmp();b.insert(0,b.iconCmp)}else{if(c){if(d){b.iconCmp.destroy();delete b.iconCmp}else{c.removeCls(c.iconCls);c.addCls(a);c.iconCls=a}}}},setIcon:function(a){var b=this,d=!a||!a.length,c=b.iconCmp;b.icon=a;if(!b.iconCmp&&!d){b.initIconCmp();b.insert(0,b.iconCmp)}else{if(c){if(d){b.iconCmp.destroy();delete b.iconCmp}else{c.setSrc(b.icon)}}}},addTool:function(a){this.tools.push(this.add(a))},onAdd:function(b,a){this.callParent(arguments);if(b instanceof Ext.panel.Tool){b.bindTo(this.ownerCt);this.tools[b.type]=b}},initRenderData:function(){return Ext.applyIf(this.callParent(),{bodyCls:this.bodyCls})}});Ext.define("Ext.fx.target.Target",{isAnimTarget:true,constructor:function(a){this.target=a;this.id=this.getId()},getId:function(){return this.target.id}});Ext.define("Ext.fx.target.Element",{extend:"Ext.fx.target.Target",type:"element",getElVal:function(b,a,c){if(c==undefined){if(a==="x"){c=b.getX()}else{if(a==="y"){c=b.getY()}else{if(a==="scrollTop"){c=b.getScroll().top}else{if(a==="scrollLeft"){c=b.getScroll().left}else{if(a==="height"){c=b.getHeight()}else{if(a==="width"){c=b.getWidth()}else{c=b.getStyle(a)}}}}}}}return c},getAttr:function(a,c){var b=this.target;return[[b,this.getElVal(b,a,c)]]},setAttr:function(l){var g=this.target,k=l.length,n,h,b,e,c,a,d,m;for(e=0;e<k;e++){n=l[e].attrs;for(h in n){if(n.hasOwnProperty(h)){a=n[h].length;for(c=0;c<a;c++){b=n[h][c];d=b[0];m=b[1];if(h==="x"){d.setX(m)}else{if(h==="y"){d.setY(m)}else{if(h==="scrollTop"){d.scrollTo("top",m)}else{if(h==="scrollLeft"){d.scrollTo("left",m)}else{if(h==="width"){d.setWidth(m)}else{if(h==="height"){d.setHeight(m)}else{d.setStyle(h,m)}}}}}}}}}}}});Ext.define("Ext.fx.target.ElementCSS",{extend:"Ext.fx.target.Element",setAttr:function(n,e){var q={attrs:[],duration:[],easing:[]},m=n.length,g,p,k,l,c,b,h,d,a;for(h=0;h<m;h++){p=n[h];c=p.duration;l=p.easing;p=p.attrs;for(k in p){if(Ext.Array.indexOf(q.attrs,k)==-1){q.attrs.push(k.replace(/[A-Z]/g,function(i){return"-"+i.toLowerCase()}));q.duration.push(c+"ms");q.easing.push(l)}}}g=q.attrs.join(",");c=q.duration.join(",");l=q.easing.join(", ");for(h=0;h<m;h++){p=n[h].attrs;for(k in p){a=p[k].length;for(d=0;d<a;d++){b=p[k][d];b[0].setStyle(Ext.supports.CSS3Prefix+"TransitionProperty",e?"":g);b[0].setStyle(Ext.supports.CSS3Prefix+"TransitionDuration",e?"":c);b[0].setStyle(Ext.supports.CSS3Prefix+"TransitionTimingFunction",e?"":l);b[0].setStyle(k,b[1]);if(e){b=b[0].dom.offsetWidth}else{b[0].on(Ext.supports.CSS3TransitionEnd,function(){this.setStyle(Ext.supports.CSS3Prefix+"TransitionProperty",null);this.setStyle(Ext.supports.CSS3Prefix+"TransitionDuration",null);this.setStyle(Ext.supports.CSS3Prefix+"TransitionTimingFunction",null)},b[0],{single:true})}}}}}});Ext.define("Ext.fx.target.CompositeElement",{extend:"Ext.fx.target.Element",isComposite:true,constructor:function(a){a.id=a.id||Ext.id(null,"ext-composite-");this.callParent([a])},getAttr:function(a,h){var b=[],g=this.target.elements,e=g.length,c,d;for(c=0;c<e;c++){d=g[c];if(d){d=this.target.getElement(d);b.push([d,this.getElVal(d,a,h)])}}return b}});Ext.define("Ext.fx.target.CompositeElementCSS",{extend:"Ext.fx.target.CompositeElement",requires:["Ext.fx.target.ElementCSS"],setAttr:function(){return Ext.fx.target.ElementCSS.prototype.setAttr.apply(this,arguments)}});Ext.define("Ext.fx.target.Sprite",{extend:"Ext.fx.target.Target",type:"draw",getFromPrim:function(b,a){var c;switch(a){case"rotate":case"rotation":c=b.attr.rotation;return{x:c.x||0,y:c.y||0,degrees:c.degrees||0};case"scale":case"scaling":c=b.attr.scaling;return{x:c.x||1,y:c.y||1,cx:c.cx||0,cy:c.cy||0};case"translate":case"translation":c=b.attr.translation;return{x:c.x||0,y:c.y||0};default:return b.attr[a]}},getAttr:function(a,b){return[[this.target,b!=undefined?b:this.getFromPrim(this.target,a)]]},setAttr:function(m){var g=m.length,k=[],b,e,p,r,q,o,n,d,c,l,h,a;for(d=0;d<g;d++){b=m[d].attrs;for(e in b){p=b[e];a=p.length;for(c=0;c<a;c++){q=p[c][0];r=p[c][1];if(e==="translate"||e==="translation"){n={x:r.x,y:r.y}}else{if(e==="rotate"||e==="rotation"){l=r.x;if(isNaN(l)){l=null}h=r.y;if(isNaN(h)){h=null}n={degrees:r.degrees,x:l,y:h}}else{if(e==="scale"||e==="scaling"){l=r.x;if(isNaN(l)){l=null}h=r.y;if(isNaN(h)){h=null}n={x:l,y:h,cx:r.cx,cy:r.cy}}else{if(e==="width"||e==="height"||e==="x"||e==="y"){n=parseFloat(r)}else{n=r}}}}o=Ext.Array.indexOf(k,q);if(o==-1){k.push([q,{}]);o=k.length-1}k[o][1][e]=n}}}g=k.length;for(d=0;d<g;d++){k[d][0].setAttributes(k[d][1])}this.target.redraw()}});Ext.define("Ext.fx.target.CompositeSprite",{extend:"Ext.fx.target.Sprite",getAttr:function(a,h){var b=[],g=[].concat(this.target.items),e=g.length,d,c;for(d=0;d<e;d++){c=g[d];b.push([c,h!=undefined?h:this.getFromPrim(c,a)])}return b}});Ext.define("Ext.fx.target.Component",{extend:"Ext.fx.target.Target",type:"component",getPropMethod:{top:function(){return this.getPosition(true)[1]},left:function(){return this.getPosition(true)[0]},x:function(){return this.getPosition()[0]},y:function(){return this.getPosition()[1]},height:function(){return this.getHeight()},width:function(){return this.getWidth()},opacity:function(){return this.el.getStyle("opacity")}},compMethod:{top:"setPosition",left:"setPosition",x:"setPagePosition",y:"setPagePosition",height:"setSize",width:"setSize",opacity:"setOpacity"},getAttr:function(a,b){return[[this.target,b!==undefined?b:this.getPropMethod[a].call(this.target)]]},setAttr:function(t,e,b){var r=this,m=r.target,q=t.length,v,n,a,g,d,p,l,c,s,u,k;for(g=0;g<q;g++){v=t[g].attrs;for(n in v){l=v[n].length;p={setPosition:{},setPagePosition:{},setSize:{},setOpacity:{}};for(d=0;d<l;d++){a=v[n][d];p[r.compMethod[n]].target=a[0];p[r.compMethod[n]][n]=a[1]}if(p.setPosition.target){a=p.setPosition;c=(a.left===undefined)?undefined:parseFloat(a.left);s=(a.top===undefined)?undefined:parseFloat(a.top);a.target.setPosition(c,s)}if(p.setPagePosition.target){a=p.setPagePosition;a.target.setPagePosition(a.x,a.y)}if(p.setSize.target){a=p.setSize;u=(a.width===undefined)?a.target.getWidth():parseFloat(a.width);k=(a.height===undefined)?a.target.getHeight():parseFloat(a.height);if(b||r.dynamic){a.target.setSize(u,k)}else{a.target.el.setSize(u,k)}}if(p.setOpacity.target){a=p.setOpacity;a.target.el.setStyle("opacity",a.opacity)}}}}});Ext.define("Ext.fx.Queue",{requires:["Ext.util.HashMap"],constructor:function(){this.targets=new Ext.util.HashMap();this.fxQueue={}},getFxDefaults:function(a){var b=this.targets.get(a);if(b){return b.fxDefaults}return{}},setFxDefaults:function(a,c){var b=this.targets.get(a);if(b){b.fxDefaults=Ext.apply(b.fxDefaults||{},c)}},stopAnimation:function(b){var d=this,a=d.getFxQueue(b),c=a.length;while(c){a[c-1].end();c--}},getActiveAnimation:function(b){var a=this.getFxQueue(b);return(a&&!!a.length)?a[0]:false},hasFxBlock:function(b){var a=this.getFxQueue(b);return a&&a[0]&&a[0].block},getFxQueue:function(b){if(!b){return false}var c=this,a=c.fxQueue[b],d=c.targets.get(b);if(!d){return false}if(!a){c.fxQueue[b]=[];if(d.type!="element"){d.target.on("destroy",function(){c.fxQueue[b]=[]})}}return c.fxQueue[b]},queueFx:function(d){var c=this,e=d.target,a,b;if(!e){return}a=c.getFxQueue(e.getId());b=a.length;if(b){if(d.concurrent){d.paused=false}else{a[b-1].on("afteranimate",function(){d.paused=false})}}else{d.paused=false}d.on("afteranimate",function(){Ext.Array.remove(a,d);if(d.remove){if(e.type=="element"){var g=Ext.get(e.id);if(g){g.remove()}}}},this);a.push(d)}});Ext.define("Ext.fx.Manager",{singleton:true,requires:["Ext.util.MixedCollection","Ext.fx.target.Element","Ext.fx.target.ElementCSS","Ext.fx.target.CompositeElement","Ext.fx.target.CompositeElementCSS","Ext.fx.target.Sprite","Ext.fx.target.CompositeSprite","Ext.fx.target.Component"],mixins:{queue:"Ext.fx.Queue"},constructor:function(){this.items=new Ext.util.MixedCollection();this.mixins.queue.constructor.call(this)},interval:16,forceJS:true,createTarget:function(d){var b=this,c=!b.forceJS&&Ext.supports.Transitions,a;b.useCSS3=c;if(d){if(d.tagName||Ext.isString(d)||d.isFly){d=Ext.get(d);a=new Ext.fx.target["Element"+(c?"CSS":"")](d)}else{if(d.dom){a=new Ext.fx.target["Element"+(c?"CSS":"")](d)}else{if(d.isComposite){a=new Ext.fx.target["CompositeElement"+(c?"CSS":"")](d)}else{if(d.isSprite){a=new Ext.fx.target.Sprite(d)}else{if(d.isCompositeSprite){a=new Ext.fx.target.CompositeSprite(d)}else{if(d.isComponent){a=new Ext.fx.target.Component(d)}else{if(d.isAnimTarget){return d}else{return null}}}}}}}b.targets.add(a);return a}else{return null}},addAnim:function(c){var b=this.items,a=this.task;b.add(c.id,c);if(!a&&b.length){a=this.task={run:this.runner,interval:this.interval,scope:this};Ext.TaskManager.start(a)}},removeAnim:function(d){var c=this,b=c.items,a=c.task;b.removeAtKey(d.id);if(a&&!b.length){Ext.TaskManager.stop(a);delete c.task}},runner:function(){var d=this,b=d.items.getRange(),c=0,a=b.length,e;d.targetArr={};d.timestamp=new Date();for(;c<a;c++){e=b[c];if(e.isReady()){d.startAnim(e)}}for(c=0;c<a;c++){e=b[c];if(e.isRunning()){d.runAnim(e)}}d.applyPendingAttrs()},startAnim:function(a){a.start(this.timestamp)},runAnim:function(e){if(!e){return}var d=this,b=e.target.getId(),h=d.useCSS3&&e.target.type=="element",a=d.timestamp-e.startTime,c=(a>=e.duration),g,i;g=this.collectTargetData(e,a,h,c);if(h){e.target.setAttr(g.anims[e.id].attributes,true);d.collectTargetData(e,e.duration,h,c);e.paused=true;g=e.target.target;if(e.target.isComposite){g=e.target.target.last()}i={};i[Ext.supports.CSS3TransitionEnd]=e.lastFrame;i.scope=e;i.single=true;g.on(i)}},collectTargetData:function(c,a,e,g){var b=c.target.getId(),d=this.targetArr[b];if(!d){d=this.targetArr[b]={id:b,el:c.target,anims:{}}}d.anims[c.id]={id:c.id,anim:c,elapsed:a,isLastFrame:g,attributes:[{duration:c.duration,easing:(e&&c.reverse)?c.easingFn.reverse().toCSS3():c.easing,attrs:c.runAnim(a)}]};return d},applyPendingAttrs:function(){var e=this.targetArr,g,c,b,d,a;for(c in e){if(e.hasOwnProperty(c)){g=e[c];for(a in g.anims){if(g.anims.hasOwnProperty(a)){b=g.anims[a];d=b.anim;if(b.attributes&&d.isRunning()){g.el.setAttr(b.attributes,false,b.isLastFrame);if(b.isLastFrame){d.lastFrame()}}}}}}}});Ext.define("Ext.fx.Animator",{mixins:{observable:"Ext.util.Observable"},requires:["Ext.fx.Manager"],isAnimator:true,duration:250,delay:0,delayStart:0,dynamic:false,easing:"ease",running:false,paused:false,damper:1,iterations:1,currentIteration:0,keyframeStep:0,animKeyFramesRE:/^(from|to|\d+%?)$/,constructor:function(a){var b=this;a=Ext.apply(b,a||{});b.config=a;b.id=Ext.id(null,"ext-animator-");b.addEvents("beforeanimate","keyframe","afteranimate");b.mixins.observable.constructor.call(b,a);b.timeline=[];b.createTimeline(b.keyframes);if(b.target){b.applyAnimator(b.target);Ext.fx.Manager.addAnim(b)}},sorter:function(d,c){return d.pct-c.pct},createTimeline:function(g){var k=this,n=[],l=k.to||{},c=k.duration,o,a,e,j,m,b,d,h;for(m in g){if(g.hasOwnProperty(m)&&k.animKeyFramesRE.test(m)){h={attrs:Ext.apply(g[m],l)};if(m=="from"){m=0}else{if(m=="to"){m=100}}h.pct=parseInt(m,10);n.push(h)}}Ext.Array.sort(n,k.sorter);j=n.length;for(e=0;e<j;e++){o=(n[e-1])?c*(n[e-1].pct/100):0;a=c*(n[e].pct/100);k.timeline.push({duration:a-o,attrs:n[e].attrs})}},applyAnimator:function(e){var k=this,l=[],o=k.timeline,g=k.reverse,j=o.length,b,h,a,d,n,m,c;if(k.fireEvent("beforeanimate",k)!==false){for(c=0;c<j;c++){b=o[c];n=b.attrs;h=n.easing||k.easing;a=n.damper||k.damper;delete n.easing;delete n.damper;b=new Ext.fx.Anim({target:e,easing:h,damper:a,duration:b.duration,paused:true,to:n});l.push(b)}k.animations=l;k.target=b.target;for(c=0;c<j-1;c++){b=l[c];b.nextAnim=l[c+1];b.on("afteranimate",function(){this.nextAnim.paused=false});b.on("afteranimate",function(){this.fireEvent("keyframe",this,++this.keyframeStep)},k)}l[j-1].on("afteranimate",function(){this.lastFrame()},k)}},start:function(d){var e=this,c=e.delay,b=e.delayStart,a;if(c){if(!b){e.delayStart=d;return}else{a=d-b;if(a<c){return}else{d=new Date(b.getTime()+c)}}}if(e.fireEvent("beforeanimate",e)!==false){e.startTime=d;e.running=true;e.animations[e.keyframeStep].paused=false}},lastFrame:function(){var c=this,a=c.iterations,b=c.currentIteration;b++;if(b<a){c.startTime=new Date();c.currentIteration=b;c.keyframeStep=0;c.applyAnimator(c.target);c.animations[c.keyframeStep].paused=false}else{c.currentIteration=0;c.end()}},end:function(){var a=this;a.fireEvent("afteranimate",a,a.startTime,new Date()-a.startTime)},isReady:function(){return this.paused===false&&this.running===false&&this.iterations>0},isRunning:function(){return false}});Ext.define("Ext.fx.CubicBezier",{singleton:true,cubicBezierAtTime:function(o,d,b,n,m,i){var j=3*d,l=3*(n-d)-j,a=1-j-l,h=3*b,k=3*(m-b)-h,p=1-h-k;function g(q){return((a*q+l)*q+j)*q}function c(q,s){var r=e(q,s);return((p*r+k)*r+h)*r}function e(q,y){var w,v,t,r,u,s;for(t=q,s=0;s<8;s++){r=g(t)-q;if(Math.abs(r)<y){return t}u=(3*a*t+2*l)*t+j;if(Math.abs(u)<0.000001){break}t=t-r/u}w=0;v=1;t=q;if(t<w){return w}if(t>v){return v}while(w<v){r=g(t);if(Math.abs(r-q)<y){return t}if(q>r){w=t}else{v=t}t=(v-w)/2+w}return t}return c(o,1/(200*i))},cubicBezier:function(b,e,a,c){var d=function(g){return Ext.fx.CubicBezier.cubicBezierAtTime(g,b,e,a,c,1)};d.toCSS3=function(){return"cubic-bezier("+[b,e,a,c].join(",")+")"};d.reverse=function(){return Ext.fx.CubicBezier.cubicBezier(1-a,1-c,1-b,1-e)};return d}});Ext.ns("Ext.fx");Ext.require("Ext.fx.CubicBezier",function(){var e=Math,h=e.PI,d=e.pow,b=e.sin,g=e.sqrt,a=e.abs,c=1.70158;Ext.fx.Easing={};Ext.apply(Ext.fx.Easing,{linear:function(i){return i},ease:function(l){var i=0.07813-l/2,m=-0.25,o=g(0.0066+i*i),r=o-i,k=d(a(r),1/3)*(r<0?-1:1),p=-o-i,j=d(a(p),1/3)*(p<0?-1:1),s=k+j+0.25;return d(1-s,2)*3*s*0.1+(1-s)*3*s*s+s*s*s},easeIn:function(i){return d(i,1.7)},easeOut:function(i){return d(i,0.48)},easeInOut:function(r){var l=0.48-r/1.04,k=g(0.1734+l*l),i=k-l,p=d(a(i),1/3)*(i<0?-1:1),o=-k-l,m=d(a(o),1/3)*(o<0?-1:1),j=p+m+0.5;return(1-j)*3*j*j+j*j*j},backIn:function(i){return i*i*((c+1)*i-c)},backOut:function(i){i=i-1;return i*i*((c+1)*i+c)+1},elasticIn:function(k){if(k===0||k===1){return k}var j=0.3,i=j/4;return d(2,-10*k)*b((k-i)*(2*h)/j)+1},elasticOut:function(i){return 1-Ext.fx.Easing.elasticIn(1-i)},bounceIn:function(i){return 1-Ext.fx.Easing.bounceOut(1-i)},bounceOut:function(m){var j=7.5625,k=2.75,i;if(m<(1/k)){i=j*m*m}else{if(m<(2/k)){m-=(1.5/k);i=j*m*m+0.75}else{if(m<(2.5/k)){m-=(2.25/k);i=j*m*m+0.9375}else{m-=(2.625/k);i=j*m*m+0.984375}}}return i}});Ext.apply(Ext.fx.Easing,{"back-in":Ext.fx.Easing.backIn,"back-out":Ext.fx.Easing.backOut,"ease-in":Ext.fx.Easing.easeIn,"ease-out":Ext.fx.Easing.easeOut,"elastic-in":Ext.fx.Easing.elasticIn,"elastic-out":Ext.fx.Easing.elasticIn,"bounce-in":Ext.fx.Easing.bounceIn,"bounce-out":Ext.fx.Easing.bounceOut,"ease-in-out":Ext.fx.Easing.easeInOut})});Ext.define("Ext.draw.Color",{colorToHexRe:/(.*?)rgb\((\d+),\s*(\d+),\s*(\d+)\)/,rgbRe:/\s*rgb\s*\(\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*\)\s*/,hexRe:/\s*#([0-9a-fA-F][0-9a-fA-F]?)([0-9a-fA-F][0-9a-fA-F]?)([0-9a-fA-F][0-9a-fA-F]?)\s*/,lightnessFactor:0.2,constructor:function(d,c,a){var b=this,e=Ext.Number.constrain;b.r=e(d,0,255);b.g=e(c,0,255);b.b=e(a,0,255)},getRed:function(){return this.r},getGreen:function(){return this.g},getBlue:function(){return this.b},getRGB:function(){var a=this;return[a.r,a.g,a.b]},getHSL:function(){var j=this,a=j.r/255,i=j.g/255,k=j.b/255,m=Math.max(a,i,k),d=Math.min(a,i,k),n=m-d,e,o=0,c=0.5*(m+d);if(d!=m){o=(c<0.5)?n/(m+d):n/(2-m-d);if(a==m){e=60*(i-k)/n}else{if(i==m){e=120+60*(k-a)/n}else{e=240+60*(a-i)/n}}if(e<0){e+=360}if(e>=360){e-=360}}return[e,o,c]},getLighter:function(b){var a=this.getHSL();b=b||this.lightnessFactor;a[2]=Ext.Number.constrain(a[2]+b,0,1);return this.fromHSL(a[0],a[1],a[2])},getDarker:function(a){a=a||this.lightnessFactor;return this.getLighter(-a)},toString:function(){var h=this,c=Math.round,e=c(h.r).toString(16),d=c(h.g).toString(16),a=c(h.b).toString(16);e=(e.length==1)?"0"+e:e;d=(d.length==1)?"0"+d:d;a=(a.length==1)?"0"+a:a;return["#",e,d,a].join("")},toHex:function(b){if(Ext.isArray(b)){b=b[0]}if(!Ext.isString(b)){return""}if(b.substr(0,1)==="#"){return b}var e=this.colorToHexRe.exec(b),g,d,a,c;if(Ext.isArray(e)){g=parseInt(e[2],10);d=parseInt(e[3],10);a=parseInt(e[4],10);c=a|(d<<8)|(g<<16);return e[1]+"#"+("000000"+c.toString(16)).slice(-6)}else{return b}},fromString:function(i){var c,e,d,a,h=parseInt;if((i.length==4||i.length==7)&&i.substr(0,1)==="#"){c=i.match(this.hexRe);if(c){e=h(c[1],16)>>0;d=h(c[2],16)>>0;a=h(c[3],16)>>0;if(i.length==4){e+=(e*16);d+=(d*16);a+=(a*16)}}}else{c=i.match(this.rgbRe);if(c){e=c[1];d=c[2];a=c[3]}}return(typeof e=="undefined")?undefined:new Ext.draw.Color(e,d,a)},getGrayscale:function(){return this.r*0.3+this.g*0.59+this.b*0.11},fromHSL:function(g,o,d){var a,b,c,e,k=[],n=Math.abs,j=Math.floor;if(o==0||g==null){k=[d,d,d]}else{g/=60;a=o*(1-n(2*d-1));b=a*(1-n(g-2*j(g/2)-1));c=d-a/2;switch(j(g)){case 0:k=[a,b,0];break;case 1:k=[b,a,0];break;case 2:k=[0,a,b];break;case 3:k=[0,b,a];break;case 4:k=[b,0,a];break;case 5:k=[a,0,b];break}k=[k[0]+c,k[1]+c,k[2]+c]}return new Ext.draw.Color(k[0]*255,k[1]*255,k[2]*255)}},function(){var a=this.prototype;this.addStatics({fromHSL:function(){return a.fromHSL.apply(a,arguments)},fromString:function(){return a.fromString.apply(a,arguments)},toHex:function(){return a.toHex.apply(a,arguments)}})});Ext.define("Ext.draw.Draw",{singleton:true,requires:["Ext.draw.Color"],pathToStringRE:/,?([achlmqrstvxz]),?/gi,pathCommandRE:/([achlmqstvz])[\s,]*((-?\d*\.?\d*(?:e[-+]?\d+)?\s*,?\s*)+)/ig,pathValuesRE:/(-?\d*\.?\d*(?:e[-+]?\d+)?)\s*,?\s*/ig,stopsRE:/^(\d+%?)$/,radian:Math.PI/180,availableAnimAttrs:{along:"along",blur:null,"clip-rect":"csv",cx:null,cy:null,fill:"color","fill-opacity":null,"font-size":null,height:null,opacity:null,path:"path",r:null,rotation:"csv",rx:null,ry:null,scale:"csv",stroke:"color","stroke-opacity":null,"stroke-width":null,translation:"csv",width:null,x:null,y:null},is:function(b,a){a=String(a).toLowerCase();return(a=="object"&&b===Object(b))||(a=="undefined"&&typeof b==a)||(a=="null"&&b===null)||(a=="array"&&Array.isArray&&Array.isArray(b))||(Object.prototype.toString.call(b).toLowerCase().slice(8,-1))==a},ellipsePath:function(b){var a=b.attr;return Ext.String.format("M{0},{1}A{2},{3},0,1,1,{0},{4}A{2},{3},0,1,1,{0},{1}z",a.x,a.y-a.ry,a.rx,a.ry,a.y+a.ry)},rectPath:function(b){var a=b.attr;if(a.radius){return Ext.String.format("M{0},{1}l{2},0a{3},{3},0,0,1,{3},{3}l0,{5}a{3},{3},0,0,1,{4},{3}l{6},0a{3},{3},0,0,1,{4},{4}l0,{7}a{3},{3},0,0,1,{3},{4}z",a.x+a.radius,a.y,a.width-a.radius*2,a.radius,-a.radius,a.height-a.radius*2,a.radius*2-a.width,a.radius*2-a.height)}else{return Ext.String.format("M{0},{1}L{2},{1},{2},{3},{0},{3}z",a.x,a.y,a.width+a.x,a.height+a.y)}},path2string:function(){return this.join(",").replace(Ext.draw.Draw.pathToStringRE,"$1")},pathToString:function(a){return a.join(",").replace(Ext.draw.Draw.pathToStringRE,"$1")},parsePathString:function(a){if(!a){return null}var d={a:7,c:6,h:1,l:2,m:2,q:4,s:4,t:2,v:1,z:0},c=[],b=this;if(b.is(a,"array")&&b.is(a[0],"array")){c=b.pathClone(a)}if(!c.length){String(a).replace(b.pathCommandRE,function(g,e,j){var i=[],h=e.toLowerCase();j.replace(b.pathValuesRE,function(l,k){k&&i.push(+k)});if(h=="m"&&i.length>2){c.push([e].concat(Ext.Array.splice(i,0,2)));h="l";e=(e=="m")?"l":"L"}while(i.length>=d[h]){c.push([e].concat(Ext.Array.splice(i,0,d[h])));if(!d[h]){break}}})}c.toString=b.path2string;return c},mapPath:function(l,g){if(!g){return l}var h,e,c,k,a,d,b;l=this.path2curve(l);for(c=0,k=l.length;c<k;c++){b=l[c];for(a=1,d=b.length;a<d-1;a+=2){h=g.x(b[a],b[a+1]);e=g.y(b[a],b[a+1]);b[a]=h;b[a+1]=e}}return l},pathClone:function(g){var c=[],a,e,b,d;if(!this.is(g,"array")||!this.is(g&&g[0],"array")){g=this.parsePathString(g)}for(b=0,d=g.length;b<d;b++){c[b]=[];for(a=0,e=g[b].length;a<e;a++){c[b][a]=g[b][a]}}c.toString=this.path2string;return c},pathToAbsolute:function(c){if(!this.is(c,"array")||!this.is(c&&c[0],"array")){c=this.parsePathString(c)}var k=[],m=0,l=0,o=0,n=0,g=0,h=c.length,b,d,e,a;if(h&&c[0][0]=="M"){m=+c[0][1];l=+c[0][2];o=m;n=l;g++;k[0]=["M",m,l]}for(;g<h;g++){b=k[g]=[];d=c[g];if(d[0]!=d[0].toUpperCase()){b[0]=d[0].toUpperCase();switch(b[0]){case"A":b[1]=d[1];b[2]=d[2];b[3]=d[3];b[4]=d[4];b[5]=d[5];b[6]=+(d[6]+m);b[7]=+(d[7]+l);break;case"V":b[1]=+d[1]+l;break;case"H":b[1]=+d[1]+m;break;case"M":o=+d[1]+m;n=+d[2]+l;default:e=1;a=d.length;for(;e<a;e++){b[e]=+d[e]+((e%2)?m:l)}}}else{e=0;a=d.length;for(;e<a;e++){k[g][e]=d[e]}}switch(b[0]){case"Z":m=o;l=n;break;case"H":m=b[1];break;case"V":l=b[1];break;case"M":d=k[g];a=d.length;o=d[a-2];n=d[a-1];default:d=k[g];a=d.length;m=d[a-2];l=d[a-1]}}k.toString=this.path2string;return k},pathToRelative:function(d){if(!this.is(d,"array")||!this.is(d&&d[0],"array")){d=this.parsePathString(d)}var n=[],p=0,o=0,t=0,s=0,c=0,a,q,h,g,e,m,u,l,b;if(d[0][0]=="M"){p=d[0][1];o=d[0][2];t=p;s=o;c++;n.push(["M",p,o])}for(h=c,u=d.length;h<u;h++){a=n[h]=[];q=d[h];if(q[0]!=q[0].toLowerCase()){a[0]=q[0].toLowerCase();switch(a[0]){case"a":a[1]=q[1];a[2]=q[2];a[3]=q[3];a[4]=q[4];a[5]=q[5];a[6]=+(q[6]-p).toFixed(3);a[7]=+(q[7]-o).toFixed(3);break;case"v":a[1]=+(q[1]-o).toFixed(3);break;case"m":t=q[1];s=q[2];default:for(g=1,l=q.length;g<l;g++){a[g]=+(q[g]-((g%2)?p:o)).toFixed(3)}}}else{a=n[h]=[];if(q[0]=="m"){t=q[1]+p;s=q[2]+o}for(e=0,b=q.length;e<b;e++){n[h][e]=q[e]}}m=n[h].length;switch(n[h][0]){case"z":p=t;o=s;break;case"h":p+=+n[h][m-1];break;case"v":o+=+n[h][m-1];break;default:p+=+n[h][m-2];o+=+n[h][m-1]}}n.toString=this.path2string;return n},path2curve:function(k){var d=this,h=d.pathToAbsolute(k),c=h.length,j={x:0,y:0,bx:0,by:0,X:0,Y:0,qx:null,qy:null},b,a,g,e;for(b=0;b<c;b++){h[b]=d.command2curve(h[b],j);if(h[b].length>7){h[b].shift();e=h[b];while(e.length){Ext.Array.splice(h,b++,0,["C"].concat(Ext.Array.splice(e,0,6)))}Ext.Array.erase(h,b,1);c=h.length;b--}a=h[b];g=a.length;j.x=a[g-2];j.y=a[g-1];j.bx=parseFloat(a[g-4])||j.x;j.by=parseFloat(a[g-3])||j.y}return h},interpolatePaths:function(r,l){var j=this,d=j.pathToAbsolute(r),m=j.pathToAbsolute(l),n={x:0,y:0,bx:0,by:0,X:0,Y:0,qx:null,qy:null},a={x:0,y:0,bx:0,by:0,X:0,Y:0,qx:null,qy:null},b=function(p,s){if(p[s].length>7){p[s].shift();var t=p[s];while(t.length){Ext.Array.splice(p,s++,0,["C"].concat(Ext.Array.splice(t,0,6)))}Ext.Array.erase(p,s,1);o=Math.max(d.length,m.length||0)}},c=function(v,u,s,p,t){if(v&&u&&v[t][0]=="M"&&u[t][0]!="M"){Ext.Array.splice(u,t,0,["M",p.x,p.y]);s.bx=0;s.by=0;s.x=v[t][1];s.y=v[t][2];o=Math.max(d.length,m.length||0)}},h,o,g,q,e,k;for(h=0,o=Math.max(d.length,m.length||0);h<o;h++){d[h]=j.command2curve(d[h],n);b(d,h);(m[h]=j.command2curve(m[h],a));b(m,h);c(d,m,n,a,h);c(m,d,a,n,h);g=d[h];q=m[h];e=g.length;k=q.length;n.x=g[e-2];n.y=g[e-1];n.bx=parseFloat(g[e-4])||n.x;n.by=parseFloat(g[e-3])||n.y;a.bx=(parseFloat(q[k-4])||a.x);a.by=(parseFloat(q[k-3])||a.y);a.x=q[k-2];a.y=q[k-1]}return[d,m]},command2curve:function(c,b){var a=this;if(!c){return["C",b.x,b.y,b.x,b.y,b.x,b.y]}if(c[0]!="T"&&c[0]!="Q"){b.qx=b.qy=null}switch(c[0]){case"M":b.X=c[1];b.Y=c[2];break;case"A":c=["C"].concat(a.arc2curve.apply(a,[b.x,b.y].concat(c.slice(1))));break;case"S":c=["C",b.x+(b.x-(b.bx||b.x)),b.y+(b.y-(b.by||b.y))].concat(c.slice(1));break;case"T":b.qx=b.x+(b.x-(b.qx||b.x));b.qy=b.y+(b.y-(b.qy||b.y));c=["C"].concat(a.quadratic2curve(b.x,b.y,b.qx,b.qy,c[1],c[2]));break;case"Q":b.qx=c[1];b.qy=c[2];c=["C"].concat(a.quadratic2curve(b.x,b.y,c[1],c[2],c[3],c[4]));break;case"L":c=["C"].concat(b.x,b.y,c[1],c[2],c[1],c[2]);break;case"H":c=["C"].concat(b.x,b.y,c[1],b.y,c[1],b.y);break;case"V":c=["C"].concat(b.x,b.y,b.x,c[1],b.x,c[1]);break;case"Z":c=["C"].concat(b.x,b.y,b.X,b.Y,b.X,b.Y);break}return c},quadratic2curve:function(b,d,h,e,a,c){var g=1/3,i=2/3;return[g*b+i*h,g*d+i*e,g*a+i*h,g*c+i*e,a,c]},rotate:function(b,h,a){var d=Math.cos(a),c=Math.sin(a),g=b*d-h*c,e=b*c+h*d;return{x:g,y:e}},arc2curve:function(v,ah,J,H,B,o,j,u,ag,C){var z=this,e=Math.PI,A=z.radian,G=e*120/180,b=A*(+B||0),O=[],L=Math,V=L.cos,a=L.sin,X=L.sqrt,w=L.abs,p=L.asin,K,c,r,Q,P,ac,d,T,W,E,D,n,m,s,l,af,g,ae,R,U,S,ad,ab,aa,Y,N,Z,M,F,I,q;if(!C){K=z.rotate(v,ah,-b);v=K.x;ah=K.y;K=z.rotate(u,ag,-b);u=K.x;ag=K.y;c=V(A*B);r=a(A*B);Q=(v-u)/2;P=(ah-ag)/2;ac=(Q*Q)/(J*J)+(P*P)/(H*H);if(ac>1){ac=X(ac);J=ac*J;H=ac*H}d=J*J;T=H*H;W=(o==j?-1:1)*X(w((d*T-d*P*P-T*Q*Q)/(d*P*P+T*Q*Q)));E=W*J*P/H+(v+u)/2;D=W*-H*Q/J+(ah+ag)/2;n=p(((ah-D)/H).toFixed(7));m=p(((ag-D)/H).toFixed(7));n=v<E?e-n:n;m=u<E?e-m:m;if(n<0){n=e*2+n}if(m<0){m=e*2+m}if(j&&n>m){n=n-e*2}if(!j&&m>n){m=m-e*2}}else{n=C[0];m=C[1];E=C[2];D=C[3]}s=m-n;if(w(s)>G){F=m;I=u;q=ag;m=n+G*(j&&m>n?1:-1);u=E+J*V(m);ag=D+H*a(m);O=z.arc2curve(u,ag,J,H,B,0,j,I,q,[m,F,E,D])}s=m-n;l=V(n);af=a(n);g=V(m);ae=a(m);R=L.tan(s/4);U=4/3*J*R;S=4/3*H*R;ad=[v,ah];ab=[v+U*af,ah-S*l];aa=[u+U*ae,ag-S*g];Y=[u,ag];ab[0]=2*ad[0]-ab[0];ab[1]=2*ad[1]-ab[1];if(C){return[ab,aa,Y].concat(O)}else{O=[ab,aa,Y].concat(O).join().split(",");N=[];M=O.length;for(Z=0;Z<M;Z++){N[Z]=Z%2?z.rotate(O[Z-1],O[Z],b).y:z.rotate(O[Z],O[Z+1],b).x}return N}},rotateAndTranslatePath:function(k){var c=k.rotation.degrees,d=k.rotation.x,b=k.rotation.y,o=k.translation.x,l=k.translation.y,n,g,a,m,e,h=[];if(!c&&!o&&!l){return this.pathToAbsolute(k.attr.path)}o=o||0;l=l||0;n=this.pathToAbsolute(k.attr.path);for(g=n.length;g--;){a=h[g]=n[g].slice();if(a[0]=="A"){m=this.rotatePoint(a[6],a[7],c,d,b);a[6]=m.x+o;a[7]=m.y+l}else{e=1;while(a[e+1]!=null){m=this.rotatePoint(a[e],a[e+1],c,d,b);a[e]=m.x+o;a[e+1]=m.y+l;e+=2}}}return h},rotatePoint:function(b,h,e,a,g){if(!e){return{x:b,y:h}}a=a||0;g=g||0;b=b-a;h=h-g;e=e*this.radian;var d=Math.cos(e),c=Math.sin(e);return{x:b*d-h*c+a,y:b*c+h*d+g}},pathDimensions:function(m){if(!m||!(m+"")){return{x:0,y:0,width:0,height:0}}m=this.path2curve(m);var k=0,j=0,d=[],b=[],e=0,h=m.length,c,a,l,g;for(;e<h;e++){c=m[e];if(c[0]=="M"){k=c[1];j=c[2];d.push(k);b.push(j)}else{g=this.curveDim(k,j,c[1],c[2],c[3],c[4],c[5],c[6]);d=d.concat(g.min.x,g.max.x);b=b.concat(g.min.y,g.max.y);k=c[5];j=c[6]}}a=Math.min.apply(0,d);l=Math.min.apply(0,b);return{x:a,y:l,path:m,width:Math.max.apply(0,d)-a,height:Math.max.apply(0,b)-l}},intersectInside:function(b,c,a){return(a[0]-c[0])*(b[1]-c[1])>(a[1]-c[1])*(b[0]-c[0])},intersectIntersection:function(n,m,g,d){var c=[],b=g[0]-d[0],a=g[1]-d[1],k=n[0]-m[0],i=n[1]-m[1],l=g[0]*d[1]-g[1]*d[0],j=n[0]*m[1]-n[1]*m[0],h=1/(b*i-a*k);c[0]=(l*k-j*b)*h;c[1]=(l*i-j*a)*h;return c},intersect:function(o,c){var n=this,k=0,m=c.length,h=c[m-1],q=o,g,r,l,p,a,b,d;for(;k<m;++k){g=c[k];b=q;q=[];r=b[b.length-1];d=0;a=b.length;for(;d<a;d++){l=b[d];if(n.intersectInside(l,h,g)){if(!n.intersectInside(r,h,g)){q.push(n.intersectIntersection(r,l,h,g))}q.push(l)}else{if(n.intersectInside(r,h,g)){q.push(n.intersectIntersection(r,l,h,g))}}r=l}h=g}return q},bezier:function(h,g,m,l,e){if(e===0){return h}else{if(e===1){return l}}var j=1-e,i=j*j*j,k=e/j;return i*(h+k*(3*g+k*(3*m+l*k)))},bezierDim:function(t,q,n,m){var v=[],g,j,p,h,u,e,w,k,o,l;if(t+3*n==m+3*q){g=t-q;g/=2*(t-q-q+n);if(g<1&&g>0){v.push(g)}}else{j=t-3*q+3*n-m;p=2*(t-q-q+n);h=t-q;u=p*p-4*j*h;e=j+j;if(u===0){g=p/e;if(g<1&&g>0){v.push(g)}}else{if(u>0){w=Math.sqrt(u);g=(w+p)/e;if(g<1&&g>0){v.push(g)}g=(p-w)/e;if(g<1&&g>0){v.push(g)}}}}k=Math.min(t,m);o=Math.max(t,m);for(l=0;l<v.length;l++){k=Math.min(k,this.bezier(t,q,n,m,v[l]));o=Math.max(o,this.bezier(t,q,n,m,v[l]))}return[k,o]},curveDim:function(b,a,d,c,k,j,h,e){var i=this.bezierDim(b,d,k,h),g=this.bezierDim(a,c,j,e);return{min:{x:i[0],y:g[0]},max:{x:i[1],y:g[1]}}},getAnchors:function(e,d,k,j,v,u,q){q=q||4;var i=Math,p=i.PI,r=p/2,m=i.abs,a=i.sin,b=i.cos,g=i.atan,t,s,h,l,o,n,x,w,c;t=(k-e)/q;s=(v-k)/q;if((j>=d&&j>=u)||(j<=d&&j<=u)){h=l=r}else{h=g((k-e)/m(j-d));if(d<j){h=p-h}l=g((v-k)/m(j-u));if(u<j){l=p-l}}c=r-((h+l)%(p*2))/2;if(c>r){c-=p}h+=c;l+=c;o=k-t*a(h);n=j+t*b(h);x=k+s*a(l);w=j+s*b(l);if((j>d&&n<d)||(j<d&&n>d)){o+=m(d-n)*(o-k)/(n-j);n=d}if((j>u&&w<u)||(j<u&&w>u)){x-=m(u-w)*(x-k)/(w-j);w=u}return{x1:o,y1:n,x2:x,y2:w}},smooth:function(a,r){var q=this.path2curve(a),e=[q[0]],k=q[0][1],h=q[0][2],s,u,v=1,l=q.length,g=1,n=k,m=h,c=0,b=0,A,z,w,o,t,p,d;for(;v<l;v++){A=q[v];z=A.length;w=q[v-1];o=w.length;t=q[v+1];p=t&&t.length;if(A[0]=="M"){n=A[1];m=A[2];s=v+1;while(q[s][0]!="C"){s++}c=q[s][5];b=q[s][6];e.push(["M",n,m]);g=e.length;k=n;h=m;continue}if(A[z-2]==n&&A[z-1]==m&&(!t||t[0]=="M")){d=e[g].length;u=this.getAnchors(w[o-2],w[o-1],n,m,e[g][d-2],e[g][d-1],r);e[g][1]=u.x2;e[g][2]=u.y2}else{if(!t||t[0]=="M"){u={x1:A[z-2],y1:A[z-1]}}else{u=this.getAnchors(w[o-2],w[o-1],A[z-2],A[z-1],t[p-2],t[p-1],r)}}e.push(["C",k,h,u.x1,u.y1,A[z-2],A[z-1]]);k=u.x2;h=u.y2}return e},findDotAtSegment:function(b,a,d,c,j,i,h,g,k){var e=1-k;return{x:Math.pow(e,3)*b+Math.pow(e,2)*3*k*d+e*3*k*k*j+Math.pow(k,3)*h,y:Math.pow(e,3)*a+Math.pow(e,2)*3*k*c+e*3*k*k*i+Math.pow(k,3)*g}},snapEnds:function(r,s,d,n){if(Ext.isDate(r)){return this.snapEndsByDate(r,s,d)}var c=(s-r)/d,a=Math.floor(Math.log(c)/Math.LN10)+1,e=Math.pow(10,a),t,p=Math.round((c%e)*Math.pow(10,2-a)),b=[[0,15],[20,4],[30,2],[40,4],[50,9],[60,4],[70,2],[80,4],[100,15]],h=0,q,k,j,g,l=1000000000,o=b.length;t=r=Math.floor(r/e)*e;if(n){for(j=0;j<o;j++){q=b[j][0];k=(q-p)<0?1000000:(q-p)/b[j][1];if(k<l){g=q;l=k}}c=Math.floor(c*Math.pow(10,-a))*Math.pow(10,a)+g*Math.pow(10,a-2);while(t<s){t+=c;h++}s=+t.toFixed(10)}else{h=d}return{from:r,to:s,power:a,step:c,steps:h}},snapEndsByDate:function(k,l,b,m){var e=false,h=[[Ext.Date.MILLI,[1,2,3,5,10,20,30,50,100,200,300,500]],[Ext.Date.SECOND,[1,2,3,5,10,15,30]],[Ext.Date.MINUTE,[1,2,3,5,10,20,30]],[Ext.Date.HOUR,[1,2,3,4,6,12]],[Ext.Date.DAY,[1,2,3,7,14]],[Ext.Date.MONTH,[1,2,3,4,6]]],g=h.length,i=false,c,d,a,n;for(n=0;n<g;n++){c=h[n];if(!i){for(d=0;d<c[1].length;d++){if(l<Ext.Date.add(k,c[0],c[1][d]*b)){e=[c[0],c[1][d]];i=true;break}}}}if(!e){a=this.snapEnds(k.getFullYear(),l.getFullYear()+1,b,m);e=[Date.YEAR,Math.round(a.step)]}return this.snapEndsByDateAndStep(k,l,e,m)},snapEndsByDateAndStep:function(i,h,e,a){var d=[i.getFullYear(),i.getMonth(),i.getDate(),i.getHours(),i.getMinutes(),i.getSeconds(),i.getMilliseconds()],b=0,g,c;if(a){g=i}else{switch(e[0]){case Ext.Date.MILLI:g=new Date(d[0],d[1],d[2],d[3],d[4],d[5],Math.floor(d[6]/e[1])*e[1]);break;case Ext.Date.SECOND:g=new Date(d[0],d[1],d[2],d[3],d[4],Math.floor(d[5]/e[1])*e[1],0);break;case Ext.Date.MINUTE:g=new Date(d[0],d[1],d[2],d[3],Math.floor(d[4]/e[1])*e[1],0,0);break;case Ext.Date.HOUR:g=new Date(d[0],d[1],d[2],Math.floor(d[3]/e[1])*e[1],0,0,0);break;case Ext.Date.DAY:g=new Date(d[0],d[1],Math.floor(d[2]-1/e[1])*e[1]+1,0,0,0,0);break;case Ext.Date.MONTH:g=new Date(d[0],Math.floor(d[1]/e[1])*e[1],1,0,0,0,0);break;default:g=new Date(Math.floor(d[0]/e[1])*e[1],0,1,0,0,0,0);break}}c=g;while(c<h){c=Ext.Date.add(c,e[0],e[1]);b++}if(a){c=h}return{from:+g,to:+c,step:(c-g)/b,steps:b}},sorter:function(d,c){return d.offset-c.offset},rad:function(a){return a%360*Math.PI/180},degrees:function(a){return a*180/Math.PI%360},withinBox:function(a,c,b){b=b||{};return(a>=b.x&&a<=(b.x+b.width)&&c>=b.y&&c<=(b.y+b.height))},parseGradient:function(k){var e=this,g=k.type||"linear",c=k.angle||0,i=e.radian,l=k.stops,a=[],j,b,h,d;if(g=="linear"){b=[0,0,Math.cos(c*i),Math.sin(c*i)];h=1/(Math.max(Math.abs(b[2]),Math.abs(b[3]))||1);b[2]*=h;b[3]*=h;if(b[2]<0){b[0]=-b[2];b[2]=0}if(b[3]<0){b[1]=-b[3];b[3]=0}}for(j in l){if(l.hasOwnProperty(j)&&e.stopsRE.test(j)){d={offset:parseInt(j,10),color:Ext.draw.Color.toHex(l[j].color)||"#ffffff",opacity:l[j].opacity||1};a.push(d)}}Ext.Array.sort(a,e.sorter);if(g=="linear"){return{id:k.id,type:g,vector:b,stops:a}}else{return{id:k.id,type:g,centerX:k.centerX,centerY:k.centerY,focalX:k.focalX,focalY:k.focalY,radius:k.radius,vector:b,stops:a}}}});Ext.define("Ext.fx.PropertyHandler",{requires:["Ext.draw.Draw"],statics:{defaultHandler:{pixelDefaultsRE:/width|height|top$|bottom$|left$|right$/i,unitRE:/^(-?\d*\.?\d*){1}(em|ex|px|in|cm|mm|pt|pc|%)*$/,scrollRE:/^scroll/i,computeDelta:function(j,c,a,g,i){a=(typeof a=="number")?a:1;var h=this.unitRE,d=h.exec(j),b,e;if(d){j=d[1];e=d[2];if(!this.scrollRE.test(i)&&!e&&this.pixelDefaultsRE.test(i)){e="px"}}j=+j||0;d=h.exec(c);if(d){c=d[1];e=d[2]||e}c=+c||0;b=(g!=null)?g:j;return{from:j,delta:(c-b)*a,units:e}},get:function(o,b,a,n,k){var m=o.length,d=[],e,h,l,c,g;for(e=0;e<m;e++){if(n){h=n[e][1].from}if(Ext.isArray(o[e][1])&&Ext.isArray(b)){l=[];c=0;g=o[e][1].length;for(;c<g;c++){l.push(this.computeDelta(o[e][1][c],b[c],a,h,k))}d.push([o[e][0],l])}else{d.push([o[e][0],this.computeDelta(o[e][1],b,a,h,k)])}}return d},set:function(l,g){var h=l.length,c=[],d,a,k,e,b;for(d=0;d<h;d++){a=l[d][1];if(Ext.isArray(a)){k=[];b=0;e=a.length;for(;b<e;b++){k.push(a[b].from+a[b].delta*g+(a[b].units||0))}c.push([l[d][0],k])}else{c.push([l[d][0],a.from+a.delta*g+(a.units||0)])}}return c}},stringHandler:{computeDelta:function(e,b,d,c,a){return{from:e,delta:b}},get:function(o,b,a,n,k){var m=o.length,d=[],e,h,l,c,g;for(e=0;e<m;e++){d.push([o[e][0],this.computeDelta(o[e][1],b,a,h,k)])}return d},set:function(l,g){var h=l.length,c=[],d,a,k,e,b;for(d=0;d<h;d++){a=l[d][1];c.push([l[d][0],a.delta])}return c}},color:{rgbRE:/^rgb\(([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\)$/i,hexRE:/^#?([0-9A-F]{2})([0-9A-F]{2})([0-9A-F]{2})$/i,hex3RE:/^#?([0-9A-F]{1})([0-9A-F]{1})([0-9A-F]{1})$/i,parseColor:function(e,a){a=(typeof a=="number")?a:1;var g=false,c=[this.hexRE,this.rgbRE,this.hex3RE],d=c.length,j,b,k,h;for(h=0;h<d;h++){k=c[h];b=(h%2===0)?16:10;j=k.exec(e);if(j&&j.length===4){if(h===2){j[1]+=j[1];j[2]+=j[2];j[3]+=j[3]}g={red:parseInt(j[1],b),green:parseInt(j[2],b),blue:parseInt(j[3],b)};break}}return g||e},computeDelta:function(h,a,e,c){h=this.parseColor(h);a=this.parseColor(a,e);var g=c?c:h,b=typeof g,d=typeof a;if(b=="string"||b=="undefined"||d=="string"||d=="undefined"){return a||g}return{from:h,delta:{red:Math.round((a.red-g.red)*e),green:Math.round((a.green-g.green)*e),blue:Math.round((a.blue-g.blue)*e)}}},get:function(j,a,g,d){var h=j.length,c=[],e,b;for(e=0;e<h;e++){if(d){b=d[e][1].from}c.push([j[e][0],this.computeDelta(j[e][1],a,g,b)])}return c},set:function(k,e){var g=k.length,c=[],d,b,a,h,j;for(d=0;d<g;d++){b=k[d][1];if(b){h=b.from;j=b.delta;b=(typeof b=="object"&&"red" in b)?"rgb("+b.red+", "+b.green+", "+b.blue+")":b;b=(typeof b=="object"&&b.length)?b[0]:b;if(typeof b=="undefined"){return[]}a=typeof b=="string"?b:"rgb("+[(h.red+Math.round(j.red*e))%256,(h.green+Math.round(j.green*e))%256,(h.blue+Math.round(j.blue*e))%256].join(",")+")";c.push([k[d][0],a])}}return c}},object:{interpolate:function(d,b){b=(typeof b=="number")?b:1;var a={},c;for(c in d){a[c]=parseFloat(d[c])*b}return a},computeDelta:function(h,a,c,b){h=this.interpolate(h);a=this.interpolate(a,c);var g=b?b:h,e={},d;for(d in a){e[d]=a[d]-g[d]}return{from:h,delta:e}},get:function(j,a,g,d){var h=j.length,c=[],e,b;for(e=0;e<h;e++){if(d){b=d[e][1].from}c.push([j[e][0],this.computeDelta(j[e][1],a,g,b)])}return c},set:function(l,g){var h=l.length,c=[],e={},d,j,k,b,a;for(d=0;d<h;d++){b=l[d][1];j=b.from;k=b.delta;for(a in j){e[a]=j[a]+k[a]*g}c.push([l[d][0],e])}return c}},path:{computeDelta:function(e,a,c,b){c=(typeof c=="number")?c:1;var d;e=+e||0;a=+a||0;d=(b!=null)?b:e;return{from:e,delta:(a-d)*c}},forcePath:function(a){if(!Ext.isArray(a)&&!Ext.isArray(a[0])){a=Ext.draw.Draw.parsePathString(a)}return a},get:function(b,l,a,q){var c=this.forcePath(l),n=[],s=b.length,d,h,o,g,p,m,e,t,r;for(o=0;o<s;o++){r=this.forcePath(b[o][1]);g=Ext.draw.Draw.interpolatePaths(r,c);r=g[0];c=g[1];d=r.length;t=[];for(m=0;m<d;m++){g=[r[m][0]];h=r[m].length;for(e=1;e<h;e++){p=q&&q[0][1][m][e].from;g.push(this.computeDelta(r[m][e],c[m][e],a,p))}t.push(g)}n.push([b[o][0],t])}return n},set:function(p,n){var o=p.length,e=[],h,g,d,l,m,c,a,b;for(h=0;h<o;h++){c=p[h][1];l=[];a=c.length;for(g=0;g<a;g++){m=[c[g][0]];b=c[g].length;for(d=1;d<b;d++){m.push(c[g][d].from+c[g][d].delta*n)}l.push(m.join(","))}e.push([p[h][0],l.join(",")])}return e}}}},function(){var b=["outlineColor","backgroundColor","borderColor","borderTopColor","borderRightColor","borderBottomColor","borderLeftColor","fill","stroke"],c=b.length,a=0,d;for(;a<c;a++){d=b[a];this[d]=this.color}b=["cursor"];c=b.length;a=0;for(;a<c;a++){d=b[a];this[d]=this.stringHandler}});Ext.define("Ext.fx.Anim",{mixins:{observable:"Ext.util.Observable"},requires:["Ext.fx.Manager","Ext.fx.Animator","Ext.fx.Easing","Ext.fx.CubicBezier","Ext.fx.PropertyHandler"],isAnimation:true,duration:250,delay:0,delayStart:0,dynamic:false,easing:"ease",damper:1,bezierRE:/^(?:cubic-)?bezier\(([^,]+),([^,]+),([^,]+),([^\)]+)\)/,reverse:false,running:false,paused:false,iterations:1,alternate:false,currentIteration:0,startTime:0,frameCount:0,constructor:function(a){var b=this,c;a=a||{};if(a.keyframes){return new Ext.fx.Animator(a)}Ext.apply(b,a);if(b.from===undefined){b.from={}}b.propHandlers={};b.config=a;b.target=Ext.fx.Manager.createTarget(b.target);b.easingFn=Ext.fx.Easing[b.easing];b.target.dynamic=b.dynamic;if(!b.easingFn){b.easingFn=String(b.easing).match(b.bezierRE);if(b.easingFn&&b.easingFn.length==5){c=b.easingFn;b.easingFn=Ext.fx.CubicBezier.cubicBezier(+c[1],+c[2],+c[3],+c[4])}}b.id=Ext.id(null,"ext-anim-");b.addEvents("beforeanimate","afteranimate","lastframe");b.mixins.observable.constructor.call(b);Ext.fx.Manager.addAnim(b)},setAttr:function(a,b){return Ext.fx.Manager.items.get(this.id).setAttr(this.target,a,b)},initAttrs:function(){var e=this,h=e.from,i=e.to,g=e.initialFrom||{},c={},a,b,j,d;for(d in i){if(i.hasOwnProperty(d)){a=e.target.getAttr(d,h[d]);b=i[d];if(!Ext.fx.PropertyHandler[d]){if(Ext.isObject(b)){j=e.propHandlers[d]=Ext.fx.PropertyHandler.object}else{j=e.propHandlers[d]=Ext.fx.PropertyHandler.defaultHandler}}else{j=e.propHandlers[d]=Ext.fx.PropertyHandler[d]}c[d]=j.get(a,b,e.damper,g[d],d)}}e.currentAttrs=c},start:function(d){var e=this,c=e.delay,b=e.delayStart,a;if(c){if(!b){e.delayStart=d;return}else{a=d-b;if(a<c){return}else{d=new Date(b.getTime()+c)}}}if(e.fireEvent("beforeanimate",e)!==false){e.startTime=d;if(!e.paused&&!e.currentAttrs){e.initAttrs()}e.running=true;e.frameCount=0}},runAnim:function(l){var i=this,k=i.currentAttrs,d=i.duration,c=i.easingFn,b=i.propHandlers,g={},h,j,e,a;if(l>=d){l=d;a=true}if(i.reverse){l=d-l}for(e in k){if(k.hasOwnProperty(e)){j=k[e];h=a?1:c(l/d);g[e]=b[e].set(j,h)}}i.frameCount++;return g},lastFrame:function(){var c=this,a=c.iterations,b=c.currentIteration;b++;if(b<a){if(c.alternate){c.reverse=!c.reverse}c.startTime=new Date();c.currentIteration=b;c.paused=false}else{c.currentIteration=0;c.end();c.fireEvent("lastframe",c,c.startTime)}},endWasCalled:0,end:function(){if(this.endWasCalled++){return}var a=this;a.startTime=0;a.paused=false;a.running=false;Ext.fx.Manager.removeAnim(a);a.fireEvent("afteranimate",a,a.startTime);Ext.callback(a.callback,a.scope,[a,a.startTime])},isReady:function(){return this.paused===false&&this.running===false&&this.iterations>0},isRunning:function(){return this.paused===false&&this.running===true&&this.isAnimator!==true}});Ext.enableFx=true;Ext.define("Ext.dd.DragDrop",{requires:["Ext.dd.DragDropManager"],constructor:function(c,a,b){if(c){this.init(c,a,b)}},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},moveOnly:false,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(a,b){},startDrag:function(a,b){},b4Drag:function(a){},onDrag:function(a){},onDragEnter:function(a,b){},b4DragOver:function(a){},onDragOver:function(a,b){},b4DragOut:function(a){},onDragOut:function(a,b){},b4DragDrop:function(a){},onDragDrop:function(a,b){},onInvalidDrop:function(a){},b4EndDrag:function(a){},endDrag:function(a){},b4MouseDown:function(a){},onMouseDown:function(a){},onMouseUp:function(a){},onAvailable:function(){},defaultPadding:{left:0,right:0,top:0,bottom:0},constrainTo:function(i,g,n){if(Ext.isNumber(g)){g={left:g,right:g,top:g,bottom:g}}g=g||this.defaultPadding;var k=Ext.get(this.getEl()).getBox(),a=Ext.get(i),m=a.getScroll(),j,d=a.dom,l,h,e;if(d==document.body){j={x:m.left,y:m.top,width:Ext.Element.getViewWidth(),height:Ext.Element.getViewHeight()}}else{l=a.getXY();j={x:l[0],y:l[1],width:d.clientWidth,height:d.clientHeight}}h=k.y-j.y;e=k.x-j.x;this.resetConstraints();this.setXConstraint(e-(g.left||0),j.width-e-k.width-(g.right||0),this.xTickSize);this.setYConstraint(h-(g.top||0),j.height-h-k.height-(g.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(c,a,b){this.initTarget(c,a,b);Ext.EventManager.on(this.id,"mousedown",this.handleMouseDown,this)},initTarget:function(c,a,b){this.config=b||{};this.DDMInstance=Ext.dd.DragDropManager;this.groups={};if(typeof c!=="string"){c=Ext.id(c)}this.id=c;this.addToGroup((a)?a:"default");this.handleElId=c;this.setDragElId(c);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(c,a,d,b){if(!a&&0!==a){this.padding=[c,c,c,c]}else{if(!d&&0!==d){this.padding=[c,a,c,a]}else{this.padding=[c,a,d,b]}}},setInitPosition:function(d,c){var e=this.getEl(),b,a,g;if(!this.DDMInstance.verifyEl(e)){return}b=d||0;a=c||0;g=Ext.Element.getXY(e);this.initPageX=g[0]-b;this.initPageY=g[1]-a;this.lastPageX=g[0];this.lastPageY=g[1];this.setStartPosition(g)},setStartPosition:function(b){var a=b||Ext.Element.getXY(this.getEl());this.deltaSetXY=null;this.startPageX=a[0];this.startPageY=a[1]},addToGroup:function(a){this.groups[a]=true;this.DDMInstance.regDragDrop(this,a)},removeFromGroup:function(a){if(this.groups[a]){delete this.groups[a]}this.DDMInstance.removeDDFromGroup(this,a)},setDragElId:function(a){this.dragElId=a},setHandleElId:function(a){if(typeof a!=="string"){a=Ext.id(a)}this.handleElId=a;this.DDMInstance.regHandle(this.id,a)},setOuterHandleElId:function(a){if(typeof a!=="string"){a=Ext.id(a)}Ext.EventManager.on(a,"mousedown",this.handleMouseDown,this);this.setHandleElId(a);this.hasOuterHandles=true},unreg:function(){Ext.EventManager.un(this.id,"mousedown",this.handleMouseDown,this);this._domRef=null;this.DDMInstance._remove(this)},destroy:function(){this.unreg()},isLocked:function(){return(this.DDMInstance.isLocked()||this.locked)},handleMouseDown:function(b,a){if(this.primaryButtonOnly&&b.button!=0){return}if(this.isLocked()){return}this.DDMInstance.refreshCache(this.groups);if(this.hasOuterHandles||this.DDMInstance.isOverTarget(b.getPoint(),this)){if(this.clickValidator(b)){this.setStartPosition();this.b4MouseDown(b);this.onMouseDown(b);this.DDMInstance.handleMouseDown(b,this);this.DDMInstance.stopEvent(b)}}},clickValidator:function(b){var a=b.getTarget();return(this.isValidHandleChild(a)&&(this.id==this.handleElId||this.DDMInstance.handleWasClicked(a,this.id)))},addInvalidHandleType:function(a){var b=a.toUpperCase();this.invalidHandleTypes[b]=b},addInvalidHandleId:function(a){if(typeof a!=="string"){a=Ext.id(a)}this.invalidHandleIds[a]=a},addInvalidHandleClass:function(a){this.invalidHandleClasses.push(a)},removeInvalidHandleType:function(a){var b=a.toUpperCase();delete this.invalidHandleTypes[b]},removeInvalidHandleId:function(a){if(typeof a!=="string"){a=Ext.id(a)}delete this.invalidHandleIds[a]},removeInvalidHandleClass:function(b){for(var c=0,a=this.invalidHandleClasses.length;c<a;++c){if(this.invalidHandleClasses[c]==b){delete this.invalidHandleClasses[c]}}},isValidHandleChild:function(d){var c=true,h,b,a;try{h=d.nodeName.toUpperCase()}catch(g){h=d.nodeName}c=c&&!this.invalidHandleTypes[h];c=c&&!this.invalidHandleIds[d.id];for(b=0,a=this.invalidHandleClasses.length;c&&b<a;++b){c=!Ext.fly(d).hasCls(this.invalidHandleClasses[b])}return c},setXTicks:function(d,a){this.xTicks=[];this.xTickSize=a;var c={},b;for(b=this.initPageX;b>=this.minX;b=b-a){if(!c[b]){this.xTicks[this.xTicks.length]=b;c[b]=true}}for(b=this.initPageX;b<=this.maxX;b=b+a){if(!c[b]){this.xTicks[this.xTicks.length]=b;c[b]=true}}Ext.Array.sort(this.xTicks,this.DDMInstance.numericSort)},setYTicks:function(d,a){this.yTicks=[];this.yTickSize=a;var c={},b;for(b=this.initPageY;b>=this.minY;b=b-a){if(!c[b]){this.yTicks[this.yTicks.length]=b;c[b]=true}}for(b=this.initPageY;b<=this.maxY;b=b+a){if(!c[b]){this.yTicks[this.yTicks.length]=b;c[b]=true}}Ext.Array.sort(this.yTicks,this.DDMInstance.numericSort)},setXConstraint:function(c,b,a){this.leftConstraint=c;this.rightConstraint=b;this.minX=this.initPageX-c;this.maxX=this.initPageX+b;if(a){this.setXTicks(this.initPageX,a)}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(a,c,b){this.topConstraint=a;this.bottomConstraint=c;this.minY=this.initPageY-a;this.maxY=this.initPageY+c;if(b){this.setYTicks(this.initPageY,b)}this.constrainY=true},resetConstraints:function(){if(this.initPageX||this.initPageX===0){var b=(this.maintainOffset)?this.lastPageX-this.initPageX:0,a=(this.maintainOffset)?this.lastPageY-this.initPageY:0;this.setInitPosition(b,a)}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(h,d){if(!d){return h}else{if(d[0]>=h){return d[0]}else{var b,a,c,g,e;for(b=0,a=d.length;b<a;++b){c=b+1;if(d[c]&&d[c]>=h){g=h-d[b];e=d[c]-h;return(e>g)?d[b]:d[c]}}return d[d.length-1]}}},toString:function(){return("DragDrop "+this.id)}});Ext.define("Ext.dd.DD",{extend:"Ext.dd.DragDrop",requires:["Ext.dd.DragDropManager"],constructor:function(c,a,b){if(c){this.init(c,a,b)}},scroll:true,autoOffset:function(c,b){var a=c-this.startPageX,d=b-this.startPageY;this.setDelta(a,d)},setDelta:function(b,a){this.deltaX=b;this.deltaY=a},setDragElPos:function(c,b){var a=this.getDragEl();this.alignElWithMouse(a,c,b)},alignElWithMouse:function(b,e,c){var g=this.getTargetCoord(e,c),d=b.dom?b:Ext.fly(b,"_dd"),l=d.getSize(),i=Ext.Element,j,a,k,h;if(!this.deltaSetXY){j=this.cachedViewportSize={width:i.getDocumentWidth(),height:i.getDocumentHeight()};a=[Math.max(0,Math.min(g.x,j.width-l.width)),Math.max(0,Math.min(g.y,j.height-l.height))];d.setXY(a);k=d.getLocalX();h=d.getLocalY();this.deltaSetXY=[k-g.x,h-g.y]}else{j=this.cachedViewportSize;d.setLeftTop(Math.max(0,Math.min(g.x+this.deltaSetXY[0],j.width-l.width)),Math.max(0,Math.min(g.y+this.deltaSetXY[1],j.height-l.height)))}this.cachePosition(g.x,g.y);this.autoScroll(g.x,g.y,b.offsetHeight,b.offsetWidth);return g},cachePosition:function(b,a){if(b){this.lastPageX=b;this.lastPageY=a}else{var c=Ext.Element.getXY(this.getEl());this.lastPageX=c[0];this.lastPageY=c[1]}},autoScroll:function(l,k,e,m){if(this.scroll){var n=Ext.Element.getViewHeight(),b=Ext.Element.getViewWidth(),p=this.DDMInstance.getScrollTop(),d=this.DDMInstance.getScrollLeft(),j=e+k,o=m+l,i=(n+p-k-this.deltaY),g=(b+d-l-this.deltaX),c=40,a=(document.all)?80:30;if(j>n&&i<c){window.scrollTo(d,p+a)}if(k<p&&p>0&&k-p<c){window.scrollTo(d,p-a)}if(o>b&&g<c){window.scrollTo(d+a,p)}if(l<d&&d>0&&l-d<c){window.scrollTo(d-a,p)}}},getTargetCoord:function(c,b){var a=c-this.deltaX,d=b-this.deltaY;if(this.constrainX){if(a<this.minX){a=this.minX}if(a>this.maxX){a=this.maxX}}if(this.constrainY){if(d<this.minY){d=this.minY}if(d>this.maxY){d=this.maxY}}a=this.getTick(a,this.xTicks);d=this.getTick(d,this.yTicks);return{x:a,y:d}},applyConfig:function(){this.callParent();this.scroll=(this.config.scroll!==false)},b4MouseDown:function(a){this.autoOffset(a.getPageX(),a.getPageY())},b4Drag:function(a){this.setDragElPos(a.getPageX(),a.getPageY())},toString:function(){return("DD "+this.id)}});Ext.define("Ext.dd.DDProxy",{extend:"Ext.dd.DD",statics:{dragElId:"ygddfdiv"},constructor:function(c,a,b){if(c){this.init(c,a,b);this.initFrame()}},resizeFrame:true,centerFrame:false,createFrame:function(){var b=this,a=document.body,d,c;if(!a||!a.firstChild){setTimeout(function(){b.createFrame()},50);return}d=this.getDragEl();if(!d){d=document.createElement("div");d.id=this.dragElId;c=d.style;c.position="absolute";c.visibility="hidden";c.cursor="move";c.border="2px solid #aaa";c.zIndex=999;a.insertBefore(d,a.firstChild)}},initFrame:function(){this.createFrame()},applyConfig:function(){this.callParent();this.resizeFrame=(this.config.resizeFrame!==false);this.centerFrame=(this.config.centerFrame);this.setDragElId(this.config.dragElId||Ext.dd.DDProxy.dragElId)},showFrame:function(e,d){var c=this.getEl(),a=this.getDragEl(),b=a.style;this._resizeProxy();if(this.centerFrame){this.setDelta(Math.round(parseInt(b.width,10)/2),Math.round(parseInt(b.height,10)/2))}this.setDragElPos(e,d);Ext.fly(a).show()},_resizeProxy:function(){if(this.resizeFrame){var a=this.getEl();Ext.fly(this.getDragEl()).setSize(a.offsetWidth,a.offsetHeight)}},b4MouseDown:function(b){var a=b.getPageX(),c=b.getPageY();this.autoOffset(a,c);this.setDragElPos(a,c)},b4StartDrag:function(a,b){this.showFrame(a,b)},b4EndDrag:function(a){Ext.fly(this.getDragEl()).hide()},endDrag:function(c){var b=this.getEl(),a=this.getDragEl();a.style.visibility="";this.beforeMove();b.style.visibility="hidden";Ext.dd.DDM.moveToEl(b,a);a.style.visibility="hidden";b.style.visibility="";this.afterDrag()},beforeMove:function(){},afterDrag:function(){},toString:function(){return("DDProxy "+this.id)}});Ext.define("Ext.dd.StatusProxy",{extend:"Ext.Component",animRepair:false,childEls:["ghost"],renderTpl:['<div class="'+Ext.baseCSSPrefix+'dd-drop-icon"></div><div id="{id}-ghost" class="'+Ext.baseCSSPrefix+'dd-drag-ghost"></div>'],constructor:function(a){var b=this;a=a||{};Ext.apply(b,{hideMode:"visibility",hidden:true,floating:true,id:b.id||Ext.id(),cls:Ext.baseCSSPrefix+"dd-drag-proxy "+this.dropNotAllowed,shadow:a.shadow||false,renderTo:Ext.getDetachedBody()});b.callParent(arguments);this.dropStatus=this.dropNotAllowed},dropAllowed:Ext.baseCSSPrefix+"dd-drop-ok",dropNotAllowed:Ext.baseCSSPrefix+"dd-drop-nodrop",setStatus:function(a){a=a||this.dropNotAllowed;if(this.dropStatus!=a){this.el.replaceCls(this.dropStatus,a);this.dropStatus=a}},reset:function(b){var c=this,a=Ext.baseCSSPrefix+"dd-drag-proxy ";c.el.replaceCls(a+c.dropAllowed,a+c.dropNotAllowed);c.dropStatus=c.dropNotAllowed;if(b){c.ghost.update("")}},update:function(a){if(typeof a=="string"){this.ghost.update(a)}else{this.ghost.update("");a.style.margin="0";this.ghost.dom.appendChild(a)}var b=this.ghost.dom.firstChild;if(b){Ext.fly(b).setStyle("float","none")}},getGhost:function(){return this.ghost},hide:function(a){this.callParent();if(a){this.reset(true)}},stop:function(){if(this.anim&&this.anim.isAnimated&&this.anim.isAnimated()){this.anim.stop()}},sync:function(){this.el.sync()},repair:function(c,d,a){var b=this;b.callback=d;b.scope=a;if(c&&b.animRepair!==false){b.el.addCls(Ext.baseCSSPrefix+"dd-drag-repair");b.el.hideUnders(true);b.anim=b.el.animate({duration:b.repairDuration||500,easing:"ease-out",to:{x:c[0],y:c[1]},stopAnimation:true,callback:b.afterRepair,scope:b})}else{b.afterRepair()}},afterRepair:function(){var a=this;a.hide(true);a.el.removeCls(Ext.baseCSSPrefix+"dd-drag-repair");if(typeof a.callback=="function"){a.callback.call(a.scope||a)}delete a.callback;delete a.scope}});Ext.define("Ext.dd.DragSource",{extend:"Ext.dd.DDProxy",requires:["Ext.dd.StatusProxy","Ext.dd.DragDropManager"],dropAllowed:Ext.baseCSSPrefix+"dd-drop-ok",dropNotAllowed:Ext.baseCSSPrefix+"dd-drop-nodrop",animRepair:true,repairHighlightColor:"c3daf9",constructor:function(b,a){this.el=Ext.get(b);if(!this.dragData){this.dragData={}}Ext.apply(this,a);if(!this.proxy){this.proxy=new Ext.dd.StatusProxy({id:this.el.id+"-drag-status-proxy",animRepair:this.animRepair})}this.callParent([this.el.dom,this.ddGroup||this.group,{dragElId:this.proxy.id,resizeFrame:false,isTarget:false,scroll:this.scroll===true}]);this.dragging=false},getDragData:function(a){return this.dragData},onDragEnter:function(c,d){var b=Ext.dd.DragDropManager.getDDById(d),a;this.cachedTarget=b;if(this.beforeDragEnter(b,c,d)!==false){if(b.isNotifyTarget){a=b.notifyEnter(this,c,this.dragData);this.proxy.setStatus(a)}else{this.proxy.setStatus(this.dropAllowed)}if(this.afterDragEnter){this.afterDragEnter(b,c,d)}}},beforeDragEnter:function(b,a,c){return true},onDragOver:function(c,d){var b=this.cachedTarget||Ext.dd.DragDropManager.getDDById(d),a;if(this.beforeDragOver(b,c,d)!==false){if(b.isNotifyTarget){a=b.notifyOver(this,c,this.dragData);this.proxy.setStatus(a)}if(this.afterDragOver){this.afterDragOver(b,c,d)}}},beforeDragOver:function(b,a,c){return true},onDragOut:function(b,c){var a=this.cachedTarget||Ext.dd.DragDropManager.getDDById(c);if(this.beforeDragOut(a,b,c)!==false){if(a.isNotifyTarget){a.notifyOut(this,b,this.dragData)}this.proxy.reset();if(this.afterDragOut){this.afterDragOut(a,b,c)}}this.cachedTarget=null},beforeDragOut:function(b,a,c){return true},onDragDrop:function(b,c){var a=this.cachedTarget||Ext.dd.DragDropManager.getDDById(c);if(this.beforeDragDrop(a,b,c)!==false){if(a.isNotifyTarget){if(a.notifyDrop(this,b,this.dragData)!==false){this.onValidDrop(a,b,c)}else{this.onInvalidDrop(a,b,c)}}else{this.onValidDrop(a,b,c)}if(this.afterDragDrop){this.afterDragDrop(a,b,c)}}delete this.cachedTarget},beforeDragDrop:function(b,a,c){return true},onValidDrop:function(b,a,c){this.hideProxy();if(this.afterValidDrop){this.afterValidDrop(b,a,c)}},getRepairXY:function(b,a){return this.el.getXY()},onInvalidDrop:function(b,a,c){if(!a){a=b;b=null;c=a.getTarget().id}this.beforeInvalidDrop(b,a,c);if(this.cachedTarget){if(this.cachedTarget.isNotifyTarget){this.cachedTarget.notifyOut(this,a,this.dragData)}this.cacheTarget=null}this.proxy.repair(this.getRepairXY(a,this.dragData),this.afterRepair,this);if(this.afterInvalidDrop){this.afterInvalidDrop(a,c)}},afterRepair:function(){var a=this;if(Ext.enableFx){a.el.highlight(a.repairHighlightColor)}a.dragging=false},beforeInvalidDrop:function(b,a,c){return true},handleMouseDown:function(b){if(this.dragging){return}var a=this.getDragData(b);if(a&&this.onBeforeDrag(a,b)!==false){this.dragData=a;this.proxy.stop();this.callParent(arguments)}},onBeforeDrag:function(a,b){return true},onStartDrag:Ext.emptyFn,alignElWithMouse:function(){this.proxy.ensureAttachedToBody(true);return this.callParent(arguments)},startDrag:function(a,b){this.proxy.reset();this.proxy.hidden=false;this.dragging=true;this.proxy.update("");this.onInitDrag(a,b);this.proxy.show()},onInitDrag:function(a,c){var b=this.el.dom.cloneNode(true);b.id=Ext.id();this.proxy.update(b);this.onStartDrag(a,c);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(a){},endDrag:function(a){this.onEndDrag(this.dragData,a)},onEndDrag:function(a,b){},autoOffset:function(a,b){this.setDelta(-12,-20)},destroy:function(){this.callParent();Ext.destroy(this.proxy)}});Ext.define("Ext.panel.Proxy",{alternateClassName:"Ext.dd.PanelProxy",moveOnDrag:true,constructor:function(a,b){var c=this;c.panel=a;c.id=c.panel.id+"-ddproxy";Ext.apply(c,b)},insertProxy:true,setStatus:Ext.emptyFn,reset:Ext.emptyFn,update:Ext.emptyFn,stop:Ext.emptyFn,sync:Ext.emptyFn,getEl:function(){return this.ghost.el},getGhost:function(){return this.ghost},getProxy:function(){return this.proxy},hide:function(){var a=this;if(a.ghost){if(a.proxy){a.proxy.remove();delete a.proxy}a.panel.unghost(null,a.moveOnDrag);delete a.ghost}},show:function(){var b=this,a;if(!b.ghost){a=b.panel.getSize();b.panel.el.setVisibilityMode(Ext.Element.DISPLAY);b.ghost=b.panel.ghost();if(b.insertProxy){b.proxy=b.panel.el.insertSibling({cls:Ext.baseCSSPrefix+"panel-dd-spacer"});b.proxy.setSize(a)}}},repair:function(b,c,a){this.hide();Ext.callback(c,a||this)},moveProxy:function(a,b){if(this.proxy){a.insertBefore(this.proxy.dom,b)}}});Ext.define("Ext.panel.DD",{extend:"Ext.dd.DragSource",requires:["Ext.panel.Proxy"],constructor:function(b,a){var c=this;c.panel=b;c.dragData={panel:b};c.panelProxy=new Ext.panel.Proxy(b,a);c.proxy=c.panelProxy.proxy;c.callParent([b.el,a]);c.setupEl(b)},setupEl:function(a){var c=this,d=a.header,b=a.body;if(d){c.setHandleElId(d.id);b=d.el}if(b){b.setStyle("cursor","move");c.scroll=false}else{a.on("boxready",c.setupEl,c,{single:true})}},showFrame:Ext.emptyFn,startDrag:Ext.emptyFn,b4StartDrag:function(a,b){this.panelProxy.show()},b4MouseDown:function(b){var a=b.getPageX(),c=b.getPageY();this.autoOffset(a,c)},onInitDrag:function(a,b){this.onStartDrag(a,b);return true},createFrame:Ext.emptyFn,getDragEl:function(a){return this.panelProxy.ghost.el.dom},endDrag:function(a){this.panelProxy.hide();this.panel.saveState()},autoOffset:function(a,b){a-=this.startPageX;b-=this.startPageY;this.setDelta(a,b)},onInvalidDrop:function(c,b,d){var a=this;a.beforeInvalidDrop(c,b,d);if(a.cachedTarget){if(a.cachedTarget.isNotifyTarget){a.cachedTarget.notifyOut(a,b,a.dragData)}a.cacheTarget=null}if(a.afterInvalidDrop){a.afterInvalidDrop(b,d)}}});Ext.define("Ext.util.Memento",(function(){function d(i,h,j,g){i[g?g+j:j]=h[j]}function c(h,g,i){delete h[i]}function e(k,j,l,i){var g=i?i+l:l,h=k[g];if(h||k.hasOwnProperty(g)){a(j,l,h)}}function a(h,i,g){if(Ext.isDefined(g)){h[i]=g}else{delete h[i]}}function b(h,m,l,i,j){if(m){if(Ext.isArray(i)){var k,g=i.length;for(k=0;k<g;k++){h(m,l,i[k],j)}}else{h(m,l,i,j)}}}return{data:null,target:null,constructor:function(h,g){if(h){this.target=h;if(g){this.capture(g)}}},capture:function(g,j,i){var h=this;b(d,h.data||(h.data={}),j||h.target,g,i)},remove:function(g){b(c,this.data,null,g)},restore:function(h,g,j,i){b(e,this.data,j||this.target,h,i);if(g!==false){this.remove(h)}},restoreAll:function(g,k){var i=this,h=k||this.target,j=i.data,l;for(l in j){if(j.hasOwnProperty(l)){a(h,l,j[l])}}if(g!==false){delete i.data}}}}()));Ext.define("Ext.panel.Panel",{extend:"Ext.panel.AbstractPanel",requires:["Ext.panel.Header","Ext.fx.Anim","Ext.util.KeyMap","Ext.panel.DD","Ext.XTemplate","Ext.layout.component.Dock","Ext.util.Memento"],alias:"widget.panel",alternateClassName:"Ext.Panel",collapsedCls:"collapsed",animCollapse:Ext.enableFx,minButtonWidth:75,collapsed:false,collapseFirst:true,hideCollapseTool:false,titleCollapse:false,floatable:true,collapsible:false,closable:false,closeAction:"destroy",placeholderCollapseHideMode:Ext.Element.VISIBILITY,preventHeader:false,header:undefined,headerPosition:"top",frame:false,frameHeader:true,titleAlign:"left",manageHeight:true,initComponent:function(){var a=this;a.addEvents("beforeclose","close","beforeexpand","beforecollapse","expand","collapse","titlechange","iconchange","iconclschange");if(a.collapsible){this.addStateEvents(["expand","collapse"])}if(a.unstyled){a.setUI("plain")}if(a.frame){a.setUI(a.ui+"-framed")}a.bridgeToolbars();a.callParent();a.collapseDirection=a.collapseDirection||a.headerPosition||Ext.Component.DIRECTION_TOP;a.hiddenOnCollapse=new Ext.dom.CompositeElement()},beforeDestroy:function(){var a=this;Ext.destroy(a.placeholder,a.ghostPanel,a.dd);a.callParent()},initAria:function(){this.callParent();this.initHeaderAria()},getFocusEl:function(){return this.el},initHeaderAria:function(){var b=this,a=b.el,c=b.header;if(a&&c){a.dom.setAttribute("aria-labelledby",c.titleCmp.id)}},getHeader:function(){return this.header},setTitle:function(g){var c=this,b=c.title,e=c.header,a=c.reExpander,d=c.placeholder;c.title=g;if(e){if(e.isHeader){e.setTitle(g)}else{e.title=g}}else{c.updateHeader()}if(a){a.setTitle(g)}if(d&&d.setTitle){d.setTitle(g)}c.fireEvent("titlechange",c,g,b)},setIconCls:function(a){var c=this,b=c.iconCls,e=c.header,d=c.placeholder;c.iconCls=a;if(e){if(e.isHeader){e.setIconCls(a)}else{e.iconCls=a}}else{c.updateHeader()}if(d&&d.setIconCls){d.setIconCls(a)}c.fireEvent("iconclschange",c,a,b)},setIcon:function(a){var b=this,c=b.icon,e=b.header,d=b.placeholder;b.icon=a;if(e){if(e.isHeader){e.setIcon(a)}else{e.icon=a}}else{b.updateHeader()}if(d&&d.setIcon){d.setIcon(a)}b.fireEvent("iconchange",b,a,c)},bridgeToolbars:function(){var a=this,g=[],c,b,e=a.minButtonWidth;function d(h,j,i){if(Ext.isArray(h)){h={xtype:"toolbar",items:h}}else{if(!h.xtype){h.xtype="toolbar"}}h.dock=j;if(j=="left"||j=="right"){h.vertical=true}if(i){h.layout=Ext.applyIf(h.layout||{},{pack:{left:"start",center:"center"}[a.buttonAlign]||"end"})}return h}if(a.tbar){g.push(d(a.tbar,"top"));a.tbar=null}if(a.bbar){g.push(d(a.bbar,"bottom"));a.bbar=null}if(a.buttons){a.fbar=a.buttons;a.buttons=null}if(a.fbar){c=d(a.fbar,"bottom",true);c.ui="footer";if(e){b=c.defaults;c.defaults=function(h){var i=b||{};if((!h.xtype||h.xtype==="button"||(h.isComponent&&h.isXType("button")))&&!("minWidth" in i)){i=Ext.apply({minWidth:e},i)}return i}}g.push(c);a.fbar=null}if(a.lbar){g.push(d(a.lbar,"left"));a.lbar=null}if(a.rbar){g.push(d(a.rbar,"right"));a.rbar=null}if(a.dockedItems){if(!Ext.isArray(a.dockedItems)){a.dockedItems=[a.dockedItems]}a.dockedItems=a.dockedItems.concat(g)}else{a.dockedItems=g}},isPlaceHolderCollapse:function(){return this.collapseMode=="placeholder"},onBoxReady:function(){this.callParent();if(this.collapsed){this.setHiddenDocked()}},beforeRender:function(){var b=this,a;b.callParent();b.initTools();if(!(b.preventHeader||(b.header===false))){b.updateHeader()}if(b.collapsed){if(b.isPlaceHolderCollapse()){b.hidden=true;b.placeholderCollapse();a=b.collapsed;b.collapsed=false}else{b.beginCollapse();b.addClsWithUI(b.collapsedCls)}}if(a){b.collapsed=a}},initTools:function(){var a=this;a.tools=a.tools?Ext.Array.clone(a.tools):[];if(a.collapsible&&!(a.hideCollapseTool||a.header===false||a.preventHeader)){a.collapseDirection=a.collapseDirection||a.headerPosition||"top";a.collapseTool=a.expandTool=Ext.widget({xtype:"tool",type:(a.collapsed&&!a.isPlaceHolderCollapse())?("expand-"+a.getOppositeDirection(a.collapseDirection)):("collapse-"+a.collapseDirection),handler:a.toggleCollapse,scope:a});if(a.collapseFirst){a.tools.unshift(a.collapseTool)}}a.addTools();if(a.closable){a.addClsWithUI("closable");a.addTool({type:"close",handler:Ext.Function.bind(a.close,a,[])})}if(a.collapseTool&&!a.collapseFirst){a.addTool(a.collapseTool)}},addTools:Ext.emptyFn,close:function(){if(this.fireEvent("beforeclose",this)!==false){this.doClose()}},doClose:function(){this.fireEvent("close",this);this[this.closeAction]()},updateHeader:function(d){var c=this,h=c.header,g=c.title,e=c.tools,b=c.icon||c.iconCls,a=c.headerPosition=="left"||c.headerPosition=="right";if((h!==false)&&(d||(g||b)||(e&&e.length)||(c.collapsible&&!c.titleCollapse))){if(h&&h.isHeader){h.show()}else{h=c.header=Ext.widget(Ext.apply({xtype:"header",title:g,titleAlign:c.titleAlign,orientation:a?"vertical":"horizontal",dock:c.headerPosition||"top",textCls:c.headerTextCls,iconCls:c.iconCls,icon:c.icon,baseCls:c.baseCls+"-header",tools:e,ui:c.ui,id:c.id+"_header",indicateDrag:c.draggable,frame:(c.frame||c.alwaysFramed)&&c.frameHeader,ignoreParentFrame:c.frame||c.overlapHeader,ignoreBorderManagement:c.frame||c.ignoreHeaderBorderManagement,listeners:c.collapsible&&c.titleCollapse?{click:c.toggleCollapse,scope:c}:null},c.header));c.addDocked(h,0);c.tools=h.tools}c.initHeaderAria()}else{if(h){h.hide()}}},setUI:function(b){var a=this;a.callParent(arguments);if(a.header&&a.header.rendered){a.header.setUI(b)}},getContentTarget:function(){return this.body},getTargetEl:function(){var a=this;return a.body||a.protoBody||a.frameBody||a.el},isVisible:function(a){var b=this;if(b.collapsed&&b.placeholder){return b.placeholder.isVisible(a)}return b.callParent(arguments)},onHide:function(){var a=this;if(a.collapsed&&a.placeholder){a.placeholder.hide()}else{a.callParent(arguments)}},onShow:function(){var a=this;if(a.collapsed&&a.placeholder){a.hidden=true;a.placeholder.show()}else{a.callParent(arguments)}},onRemoved:function(b){var a=this;a.callParent(arguments);if(a.placeholder&&!b){a.ownerCt.remove(a.placeholder,false)}},addTool:function(e){e=[].concat(e);var d=this,g=d.header,c,a=e.length,b;for(c=0;c<a;c++){b=e[c];d.tools.push(b);if(g&&g.isHeader){g.addTool(b)}}d.updateHeader()},getOppositeDirection:function(a){var b=Ext.Component;switch(a){case b.DIRECTION_TOP:return b.DIRECTION_BOTTOM;case b.DIRECTION_RIGHT:return b.DIRECTION_LEFT;case b.DIRECTION_BOTTOM:return b.DIRECTION_TOP;case b.DIRECTION_LEFT:return b.DIRECTION_RIGHT}},getWidthAuthority:function(){if(this.collapsed&&this.collapsedHorizontal()){return 1}return this.callParent()},getHeightAuthority:function(){if(this.collapsed&&this.collapsedVertical()){return 1}return this.callParent()},collapsedHorizontal:function(){var a=this.getCollapsed();return a=="left"||a=="right"},collapsedVertical:function(){var a=this.getCollapsed();return a=="top"||a=="bottom"},restoreDimension:function(){var a=this.collapseDirection;return(a==="top"||a==="bottom")?"height":"width"},getCollapsed:function(){var a=this;if(a.collapsed===true){return a.collapseDirection}return a.collapsed},getState:function(){var a=this,b=a.callParent(),c;b=a.addPropertyToState(b,"collapsed");if(a.collapsed){c=a.collapseMemento;c=c&&c.data;if(a.collapsedVertical()){if(b){delete b.height}if(c){b=a.addPropertyToState(b,"height",c.height)}}else{if(b){delete b.width}if(c){b=a.addPropertyToState(b,"width",c.width)}}}return b},findReExpander:function(h){var g=this,j=Ext.Component,e=g.dockedItems.items,a=e.length,b,d;if(g.collapseMode=="mini"){return}switch(h){case j.DIRECTION_TOP:case j.DIRECTION_BOTTOM:for(d=0;d<a;d++){b=e[d];if(!b.hidden){if(b.isHeader&&(!b.dock||b.dock=="top"||b.dock=="bottom")){return b}}}break;case j.DIRECTION_LEFT:case j.DIRECTION_RIGHT:for(d=0;d<a;d++){b=e[d];if(!b.hidden){if(b.isHeader&&(b.dock=="left"||b.dock=="right")){return b}}}break;default:throw ("Panel#findReExpander must be passed a valid collapseDirection")}},getReExpander:function(c){var b=this,d=c||b.collapseDirection,a=b.reExpander||b.findReExpander(d);b.expandDirection=b.getOppositeDirection(d);if(!a){b.reExpander=a=b.createReExpander(d,{dock:d,cls:Ext.baseCSSPrefix+"docked "+b.baseCls+"-"+b.ui+"-collapsed",ownerCt:b,ownerLayout:b.componentLayout});b.dockedItems.insert(0,a)}return a},createReExpander:function(g,e){var d=this,i=g=="left",c=g=="right",h=i||c,b,a=Ext.apply({hideMode:"offsets",title:d.title,orientation:h?"vertical":"horizontal",textCls:d.headerTextCls,icon:d.icon,iconCls:d.iconCls,baseCls:d.baseCls+"-header",ui:d.ui,frame:d.frame&&d.frameHeader,ignoreParentFrame:d.frame||d.overlapHeader,indicateDrag:d.draggable},e);if(d.collapseMode=="mini"){if(h){a.width=1}else{a.height=1}}if(!d.hideCollapseTool){b=i||(c&&d.isPlaceHolderCollapse());a[b?"items":"tools"]=[{xtype:"tool",type:"expand-"+d.getOppositeDirection(g),uiCls:["top"],handler:d.toggleCollapse,scope:d}]}a=new Ext.panel.Header(a);a.addClsWithUI(d.getHeaderCollapsedClasses(a));return a},getHeaderCollapsedClasses:function(d){var b=this,c=b.collapsedCls,a;a=[c,c+"-"+d.dock];if(b.border&&(!b.frame||(b.frame&&Ext.supports.CSS3BorderRadius))){a.push(c+"-border-"+d.dock)}return a},beginCollapse:function(){var e=this,c=e.lastBox,g=e.rendered,b=e.collapseMemento||(e.collapseMemento=new Ext.util.Memento(e)),d=e.getSizeModel(),a;b.capture(["height","minHeight","width","minWidth"]);if(c){b.capture(e.restoreDimension(),c,"last.")}if(e.collapsedVertical()){if(d.width.shrinkWrap){e.width=g?e.getWidth():e.width||e.minWidth||100}delete e.height;e.minHeight=0}else{if(e.collapsedHorizontal()){if(d.height.shrinkWrap){e.height=g?e.getHeight():e.height||e.minHeight||100}delete e.width;e.minWidth=0}}if(e.ownerCt){e.ownerCt.getLayout().beginCollapse(e)}if(!e.isPlaceHolderCollapse()){if(e.header===(a=e.getReExpander())){e.header.addClsWithUI(e.getHeaderCollapsedClasses(e.header));if(e.header.rendered){e.header.updateFrame()}}else{if(a.el){a.el.show();a.hidden=false}}}if(e.resizer){e.resizer.disable()}},beginExpand:function(){var e=this,d=e.lastBox,c=e.collapseMemento,a=this.restoreDimension(),b;c.restore(["minHeight","minWidth",a]);if(d){c.restore(a,true,d,"last.")}if(e.ownerCt){e.ownerCt.getLayout().beginExpand(e)}if(!e.isPlaceHolderCollapse()){if(e.header===(b=e.getReExpander())){e.header.removeClsWithUI(e.getHeaderCollapsedClasses(e.header));if(e.header.rendered){e.header.updateFrame()}}else{b.hidden=true;b.el.hide()}}if(e.resizer){e.resizer.enable()}},collapse:function(d,a){var c=this,e=d||c.collapseDirection,b=c.ownerCt;if(c.isCollapsingOrExpanding){return c}if(arguments.length<2){a=c.animCollapse}if(c.collapsed||c.fireEvent("beforecollapse",c,d,a)===false){return c}if(b&&c.isPlaceHolderCollapse()){return c.placeholderCollapse(d,a)}c.collapsed=e;c.beginCollapse();c.fireHierarchyEvent("collapse");return c.doCollapseExpand(1,a)},doCollapseExpand:function(a,b){var d=this,c=d.animCollapse,e=d.ownerLayout;d.animCollapse=b;d.isCollapsingOrExpanding=a;if(e&&!b){e.onContentChange(d)}else{d.updateLayout({isRoot:true})}d.animCollapse=c;return d},afterCollapse:function(b){var a=this,c=a.ownerLayout;a.isCollapsingOrExpanding=0;if(a.collapseTool){a.collapseTool.setType("expand-"+a.getOppositeDirection(a.collapseDirection))}if(c&&b){c.onContentChange(a)}a.setHiddenDocked();a.fireEvent("collapse",a)},setHiddenDocked:function(){var h=this,d=h.hiddenOnCollapse,b=h.getReExpander(),c=h.getDockedItems(),a=c.length,e=0,g;d.add(h.body);for(;e<a;e++){g=c[e];if(g&&g!==b&&g.el){d.add(g.el)}}d.setStyle("visibility","hidden")},restoreHiddenDocked:function(){var a=this.hiddenOnCollapse;a.setStyle("visibility","");a.clear()},getPlaceholder:function(c){var b=this,e=c||b.collapseDirection,a=null,d=b.placeholder;if(!d){if(b.floatable||(b.collapsible&&b.titleCollapse)){a={click:{fn:b.floatable?b.floatCollapsedPanel:b.toggleCollapse,element:"el",scope:b}}}b.placeholder=d=Ext.widget(b.createReExpander(e,{id:b.id+"-placeholder",listeners:a}))}if(!d.placeholderFor){if(!d.isComponent){b.placeholder=d=b.lookupComponent(d)}Ext.applyIf(d,{margins:b.margins,placeholderFor:b});d.addCls([Ext.baseCSSPrefix+"region-collapsed-placeholder",Ext.baseCSSPrefix+"region-collapsed-"+e+"-placeholder",b.collapsedCls])}return d},placeholderCollapse:function(e,a){var d=this,c=d.ownerCt,h=e||d.collapseDirection,b=Ext.baseCSSPrefix+"border-region-slide-in",g=d.getPlaceholder(e);d.isCollapsingOrExpanding=1;d.hidden=true;d.collapsed=h;if(g.rendered){if(g.el.dom.parentNode!==d.el.dom.parentNode){d.el.dom.parentNode.insertBefore(g.el.dom,d.el.dom)}g.hidden=false;g.el.show();c.updateLayout()}else{c.insert(c.items.indexOf(d),g)}if(d.rendered){d.el.setVisibilityMode(d.placeholderCollapseHideMode);if(a){d.el.addCls(b);g.el.hide();d.el.slideOut(h.substr(0,1),{preserveScroll:true,duration:Ext.Number.from(a,Ext.fx.Anim.prototype.duration),listeners:{afteranimate:function(){d.el.removeCls(b);g.el.show().setStyle("display","none").slideIn(h.substr(0,1),{easing:"linear",duration:100,listeners:{afteranimate:function(){g.focus();d.isCollapsingOrExpanding=0;d.fireEvent("collapse",d)}}})}}})}else{d.el.hide();d.isCollapsingOrExpanding=0;d.fireEvent("collapse",d)}}else{d.isCollapsingOrExpanding=0;d.fireEvent("collapse",d)}return d},floatCollapsedPanel:function(){var g=this,i=g.placeholder,h=i.getBox(true),d,e=Ext.baseCSSPrefix+"border-region-slide-in",b=g.collapsed,j=g.ownerCt||g,a;if(g.el.hasCls(e)){g.slideOutFloatedPanel();return}if(g.isSliding){return}g.isSliding=true;function c(l){if(!g.isDestroyed){var k=g.el.getRegion().union(i.el.getRegion()).adjust(1,-1,-1,1);if(!k.contains(l.getPoint())){g.slideOutFloatedPanel()}}}g.placeholder.el.hide();g.placeholder.hidden=true;g.el.show();g.hidden=false;g.collapsed=false;j.updateLayout();d=g.getBox(true);g.placeholder.el.show();g.placeholder.hidden=false;g.el.hide();g.hidden=true;g.collapsed=b;j.updateLayout();g.placeholderMouseMon=i.el.monitorMouseLeave(500,c);g.panelMouseMon=g.el.monitorMouseLeave(500,c);g.el.addCls(e);if(g.collapseTool){g.collapseTool.el.hide()}switch(g.collapsed){case"top":g.el.setLeftTop(h.x,h.y+h.height-1);a="t";break;case"right":g.el.setLeftTop(h.x-d.width+1,h.y);a="r";break;case"bottom":g.el.setLeftTop(h.x,h.y-d.height+1);a="b";break;case"left":g.el.setLeftTop(h.x+h.width-1,h.y);a="l";break}g.floatedFromCollapse=g.collapsed;g.collapsed=g.hidden=false;g.el.slideIn(a,{preserveScroll:true,listeners:{afteranimate:function(){g.isSliding=false}}})},isLayoutRoot:function(){if(this.floatedFromCollapse){return true}return this.callParent()},slideOutFloatedPanel:function(){var a=this,c=this.el,b;if(a.isSliding){return}a.isSliding=true;a.slideOutFloatedPanelBegin();if(typeof a.collapsed=="string"){b=a.collapsed.charAt(0)}c.slideOut(b,{preserveScroll:true,listeners:{afteranimate:function(){a.slideOutFloatedPanelEnd();a.el.removeCls(Ext.baseCSSPrefix+"border-region-slide-in");a.isSliding=false}}})},slideOutFloatedPanelBegin:function(){var a=this,b=this.el;a.collapsed=a.floatedFromCollapse;a.hidden=true;a.floatedFromCollapse=null;b.un(a.panelMouseMon);a.placeholder.el.un(a.placeholderMouseMon)},slideOutFloatedPanelEnd:function(){if(this.collapseTool){this.collapseTool.el.show()}},expand:function(a){var b=this;if(b.isCollapsingOrExpanding){return b}if(!arguments.length){a=b.animCollapse}if(!b.collapsed&&!b.floatedFromCollapse){return b}if(b.fireEvent("beforeexpand",b,a)===false){return b}if(b.isPlaceHolderCollapse()){return b.placeholderExpand(a)}b.restoreHiddenDocked();b.beginExpand();b.collapsed=false;b.fireHierarchyEvent("expand");return b.doCollapseExpand(2,a)},placeholderExpand:function(b){var d=this,h=d.collapsed,c=Ext.baseCSSPrefix+"border-region-slide-in",e,a,g;if(d.floatedFromCollapse){a=d.getPosition(true);d.slideOutFloatedPanelBegin();d.slideOutFloatedPanelEnd()}d.isCollapsingOrExpanding=2;d.placeholder.hidden=true;d.placeholder.el.hide();d.collapsed=false;d.show();if(b){if(a){e=d.el.getXY();d.el.setLeftTop(a[0],a[1]);d.el.moveTo(e[0],e[1],{duration:Ext.Number.from(b,Ext.fx.Anim.prototype.duration),listeners:{afteranimate:function(){d.el.removeCls(c);d.isCollapsingOrExpanding=0;d.fireEvent("expand",d)}}})}else{d.hidden=true;d.el.addCls(c);d.el.hide();d.collapsed=h;d.placeholder.show();g=h.substr(0,1);d.hidden=false;d.el.slideIn(g,{preserveScroll:true,duration:Ext.Number.from(b,Ext.fx.Anim.prototype.duration),listeners:{afteranimate:function(){d.collapsed=false;d.el.removeCls(c);d.placeholder.hide();d.isCollapsingOrExpanding=0;d.fireEvent("expand",d)}}})}}else{d.isCollapsingOrExpanding=0;d.fireEvent("expand",d)}return d},afterExpand:function(b){var a=this,c=a.ownerLayout;a.isCollapsingOrExpanding=0;if(a.collapseTool){a.collapseTool.setType("collapse-"+a.collapseDirection)}if(c&&b){c.onContentChange(a)}a.fireEvent("expand",a)},setBorder:function(a,c){if(c){return}var b=this,d=b.header;if(!a){a=0}else{a=Ext.Element.unitizeBox((a===true)?1:a)}if(d){if(d.isHeader){d.setBorder(a)}else{d.border=a}}if(b.rendered&&b.bodyBorder!==false){b.body.setStyle("border-width",a)}b.updateLayout();b.border=a},toggleCollapse:function(){return(this.collapsed||this.floatedFromCollapse)?this.expand():this.collapse()},getKeyMap:function(){return this.keyMap||(this.keyMap=new Ext.util.KeyMap(Ext.apply({target:this.el},this.keys)))},initDraggable:function(){this.dd=new Ext.panel.DD(this,Ext.isBoolean(this.draggable)?null:this.draggable)},ghostTools:function(){var e=[],g=this.header,d=g?g.query("tool[hidden=false]"):[],c,a,b;if(d.length){c=0;a=d.length;for(;c<a;c++){b=d[c];e.push({type:b.type})}}else{e=[{type:"placeholder"}]}return e},ghost:function(a){var d=this,b=d.ghostPanel,c=d.getBox(),e;if(!b){b=new Ext.panel.Panel({renderTo:document.body,floating:{shadow:false},frame:d.frame&&!d.alwaysFramed,alwaysFramed:d.alwaysFramed,overlapHeader:d.overlapHeader,headerPosition:d.headerPosition,baseCls:d.baseCls,cls:d.baseCls+"-ghost "+(a||"")});d.ghostPanel=b}else{b.el.show()}b.floatParent=d.floatParent;if(d.floating){b.setZIndex(Ext.Number.from(d.el.getStyle("zIndex"),0))}else{b.toFront()}if(!(d.preventHeader||(d.header===false))){e=b.header;if(e){e.suspendLayouts();Ext.Array.forEach(e.query("tool"),e.remove,e);e.resumeLayouts()}b.addTool(d.ghostTools());b.setTitle(d.title);b.setIconCls(d.iconCls)}b.setPagePosition(c.x,c.y);b.setSize(c.width,c.height);d.el.hide();return b},unghost:function(b,a){var c=this;if(!c.ghostPanel){return}if(b!==false){c.el.show();if(a!==false){c.setPagePosition(c.ghostPanel.el.getXY());if(c.hideMode=="offsets"){delete c.el.hideModeStyles}}Ext.defer(c.focus,10,c)}c.ghostPanel.el.hide()},beginDrag:function(){if(this.floatingDescendants){this.floatingDescendants.hide()}},endDrag:function(){if(this.floatingDescendants){this.floatingDescendants.show()}},initResizable:function(a){if(this.collapsed){a.disabled=true}this.callParent([a])}},function(){this.prototype.animCollapse=Ext.enableFx});Ext.define("Ext.tip.Tip",{extend:"Ext.panel.Panel",alternateClassName:"Ext.Tip",minWidth:40,maxWidth:300,shadow:"sides",defaultAlign:"tl-bl?",constrainPosition:true,autoRender:true,hidden:true,baseCls:Ext.baseCSSPrefix+"tip",floating:{shadow:true,shim:true,constrain:true},focusOnToFront:false,closeAction:"hide",ariaRole:"tooltip",alwaysFramed:true,frameHeader:false,initComponent:function(){var a=this;a.floating=Ext.apply({},{shadow:a.shadow},a.self.prototype.floating);a.callParent(arguments);a.constrain=a.constrain||a.constrainPosition},showAt:function(b){var a=this;this.callParent(arguments);if(a.isVisible()){a.setPagePosition(b[0],b[1]);if(a.constrainPosition||a.constrain){a.doConstrain()}a.toFront(true)}},showBy:function(a,b){this.showAt(this.el.getAlignToXY(a,b||this.defaultAlign))},initDraggable:function(){var a=this;a.draggable={el:a.getDragEl(),delegate:a.header.el,constrain:a,constrainTo:a.el.getScopeParent()};Ext.Component.prototype.initDraggable.call(a)},ghost:undefined,unghost:undefined});Ext.define("Ext.tip.ToolTip",{extend:"Ext.tip.Tip",alias:"widget.tooltip",alternateClassName:"Ext.ToolTip",autoHide:true,showDelay:500,hideDelay:200,dismissDelay:5000,trackMouse:false,anchorToTarget:true,anchorOffset:0,targetCounter:0,quickShowInterval:250,initComponent:function(){var a=this;a.callParent(arguments);a.lastActive=new Date();a.setTarget(a.target);a.origAnchor=a.anchor},onRender:function(b,a){var c=this;c.callParent(arguments);c.anchorCls=Ext.baseCSSPrefix+"tip-anchor-"+c.getAnchorPosition();c.anchorEl=c.el.createChild({cls:Ext.baseCSSPrefix+"tip-anchor "+c.anchorCls})},setTarget:function(d){var b=this,a=Ext.get(d),c;if(b.target){c=Ext.get(b.target);b.mun(c,"mouseover",b.onTargetOver,b);b.mun(c,"mouseout",b.onTargetOut,b);b.mun(c,"mousemove",b.onMouseMove,b)}b.target=a;if(a){b.mon(a,{freezeEvent:true,mouseover:b.onTargetOver,mouseout:b.onTargetOut,mousemove:b.onMouseMove,scope:b})}if(b.anchor){b.anchorTarget=b.target}},onMouseMove:function(d){var b=this,a=b.delegate?d.getTarget(b.delegate):b.triggerElement=true,c;if(a){b.targetXY=d.getXY();if(a===b.triggerElement){if(!b.hidden&&b.trackMouse){c=b.getTargetXY();if(b.constrainPosition){c=b.el.adjustForConstraints(c,b.el.getScopeParent())}b.setPagePosition(c)}}else{b.hide();b.lastActive=new Date(0);b.onTargetOver(d)}}else{if((!b.closable&&b.isVisible())&&b.autoHide!==false){b.hide()}}},getTargetXY:function(){var j=this,d,c,n,a,i,l,e,m,k,b,h,g;if(j.delegate){j.anchorTarget=j.triggerElement}if(j.anchor){j.targetCounter++;c=j.getOffsets();n=(j.anchorToTarget&&!j.trackMouse)?j.el.getAlignToXY(j.anchorTarget,j.getAnchorAlign()):j.targetXY;a=Ext.Element.getViewWidth()-5;i=Ext.Element.getViewHeight()-5;l=document.documentElement;e=document.body;m=(l.scrollLeft||e.scrollLeft||0)+5;k=(l.scrollTop||e.scrollTop||0)+5;b=[n[0]+c[0],n[1]+c[1]];h=j.getSize();g=j.constrainPosition;j.anchorEl.removeCls(j.anchorCls);if(j.targetCounter<2&&g){if(b[0]<m){if(j.anchorToTarget){j.defaultAlign="l-r";if(j.mouseOffset){j.mouseOffset[0]*=-1}}j.anchor="left";return j.getTargetXY()}if(b[0]+h.width>a){if(j.anchorToTarget){j.defaultAlign="r-l";if(j.mouseOffset){j.mouseOffset[0]*=-1}}j.anchor="right";return j.getTargetXY()}if(b[1]<k){if(j.anchorToTarget){j.defaultAlign="t-b";if(j.mouseOffset){j.mouseOffset[1]*=-1}}j.anchor="top";return j.getTargetXY()}if(b[1]+h.height>i){if(j.anchorToTarget){j.defaultAlign="b-t";if(j.mouseOffset){j.mouseOffset[1]*=-1}}j.anchor="bottom";return j.getTargetXY()}}j.anchorCls=Ext.baseCSSPrefix+"tip-anchor-"+j.getAnchorPosition();j.anchorEl.addCls(j.anchorCls);j.targetCounter=0;return b}else{d=j.getMouseOffset();return(j.targetXY)?[j.targetXY[0]+d[0],j.targetXY[1]+d[1]]:d}},getMouseOffset:function(){var a=this,b=a.anchor?[0,0]:[15,18];if(a.mouseOffset){b[0]+=a.mouseOffset[0];b[1]+=a.mouseOffset[1]}return b},getAnchorPosition:function(){var b=this,a;if(b.anchor){b.tipAnchor=b.anchor.charAt(0)}else{a=b.defaultAlign.match(/^([a-z]+)-([a-z]+)(\?)?$/);b.tipAnchor=a[1].charAt(0)}switch(b.tipAnchor){case"t":return"top";case"b":return"bottom";case"r":return"right"}return"left"},getAnchorAlign:function(){switch(this.anchor){case"top":return"tl-bl";case"left":return"tl-tr";case"right":return"tr-tl";default:return"bl-tl"}},getOffsets:function(){var c=this,d,b,a=c.getAnchorPosition().charAt(0);if(c.anchorToTarget&&!c.trackMouse){switch(a){case"t":b=[0,9];break;case"b":b=[0,-13];break;case"r":b=[-13,0];break;default:b=[9,0];break}}else{switch(a){case"t":b=[-15-c.anchorOffset,30];break;case"b":b=[-19-c.anchorOffset,-13-c.el.dom.offsetHeight];break;case"r":b=[-15-c.el.dom.offsetWidth,-13-c.anchorOffset];break;default:b=[25,-13-c.anchorOffset];break}}d=c.getMouseOffset();b[0]+=d[0];b[1]+=d[1];return b},onTargetOver:function(c){var b=this,a;if(b.disabled||c.within(b.target.dom,true)){return}a=c.getTarget(b.delegate);if(a){b.triggerElement=a;b.clearTimer("hide");b.targetXY=c.getXY();b.delayShow()}},delayShow:function(){var a=this;if(a.hidden&&!a.showTimer){if(Ext.Date.getElapsed(a.lastActive)<a.quickShowInterval){a.show()}else{a.showTimer=Ext.defer(a.show,a.showDelay,a)}}else{if(!a.hidden&&a.autoHide!==false){a.show()}}},onShowVeto:function(){this.callParent();this.clearTimer("show")},onTargetOut:function(b){var a=this;if(a.disabled||b.within(a.target.dom,true)){return}a.clearTimer("show");if(a.autoHide!==false){a.delayHide()}},delayHide:function(){var a=this;if(!a.hidden&&!a.hideTimer){a.hideTimer=Ext.defer(a.hide,a.hideDelay,a)}},hide:function(){var a=this;a.clearTimer("dismiss");a.lastActive=new Date();if(a.anchorEl){a.anchorEl.hide()}a.callParent(arguments);delete a.triggerElement},show:function(){var a=this;this.callParent();if(this.hidden===false){a.setPagePosition(-10000,-10000);if(a.anchor){a.anchor=a.origAnchor}if(!a.calledFromShowAt){a.showAt(a.getTargetXY())}if(a.anchor){a.syncAnchor();a.anchorEl.show()}else{a.anchorEl.hide()}}},showAt:function(b){var a=this;a.lastActive=new Date();a.clearTimers();a.calledFromShowAt=true;if(!a.isVisible()){this.callParent(arguments)}if(a.isVisible()){a.setPagePosition(b[0],b[1]);if(a.constrainPosition||a.constrain){a.doConstrain()}a.toFront(true);a.el.sync(true);if(a.dismissDelay&&a.autoHide!==false){a.dismissTimer=Ext.defer(a.hide,a.dismissDelay,a)}if(a.anchor){a.syncAnchor();if(!a.anchorEl.isVisible()){a.anchorEl.show()}}else{a.anchorEl.hide()}}delete a.calledFromShowAt},syncAnchor:function(){var c=this,a,b,d;switch(c.tipAnchor.charAt(0)){case"t":a="b";b="tl";d=[20+c.anchorOffset,1];break;case"r":a="l";b="tr";d=[-1,12+c.anchorOffset];break;case"b":a="t";b="bl";d=[20+c.anchorOffset,-1];break;default:a="r";b="tl";d=[1,12+c.anchorOffset];break}c.anchorEl.alignTo(c.el,a+"-"+b,d);c.anchorEl.setStyle("z-index",parseInt(c.el.getZIndex(),10)||0+1).setVisibilityMode(Ext.Element.DISPLAY)},setPagePosition:function(a,c){var b=this;b.callParent(arguments);if(b.anchor){b.syncAnchor()}},clearTimer:function(a){a=a+"Timer";clearTimeout(this[a]);delete this[a]},clearTimers:function(){var a=this;a.clearTimer("show");a.clearTimer("dismiss");a.clearTimer("hide")},onShow:function(){var a=this;a.callParent();a.mon(Ext.getDoc(),"mousedown",a.onDocMouseDown,a)},onHide:function(){var a=this;a.callParent();a.mun(Ext.getDoc(),"mousedown",a.onDocMouseDown,a)},onDocMouseDown:function(b){var a=this;if(!a.closable&&!b.within(a.el.dom)){a.disable();Ext.defer(a.doEnable,100,a)}},doEnable:function(){if(!this.isDestroyed){this.enable()}},onDisable:function(){this.callParent();this.clearTimers();this.hide()},beforeDestroy:function(){var a=this;a.clearTimers();Ext.destroy(a.anchorEl);delete a.anchorEl;delete a.target;delete a.anchorTarget;delete a.triggerElement;a.callParent()},onDestroy:function(){Ext.getDoc().un("mousedown",this.onDocMouseDown,this);this.callParent()}});Ext.define("Ext.tip.QuickTip",{extend:"Ext.tip.ToolTip",alias:"widget.quicktip",alternateClassName:"Ext.QuickTip",interceptTitles:false,title:"&#160;",tagConfig:{namespace:"data-",attribute:"qtip",width:"qwidth",target:"target",title:"qtitle",hide:"hide",cls:"qclass",align:"qalign",anchor:"anchor"},initComponent:function(){var a=this;a.target=a.target||Ext.getDoc();a.targets=a.targets||{};a.callParent()},register:function(c){var h=Ext.isArray(c)?c:arguments,d=0,a=h.length,g,b,e;for(;d<a;d++){c=h[d];g=c.target;if(g){if(Ext.isArray(g)){for(b=0,e=g.length;b<e;b++){this.targets[Ext.id(g[b])]=c}}else{this.targets[Ext.id(g)]=c}}}},unregister:function(a){delete this.targets[Ext.id(a)]},cancelShow:function(a){var b=this,c=b.activeTarget;a=Ext.get(a).dom;if(b.isVisible()){if(c&&c.el==a){b.hide()}}else{if(c&&c.el==a){b.clearTimer("show")}}},getTipCfg:function(d){var c=d.getTarget(),b=c.title,a;if(this.interceptTitles&&b&&Ext.isString(b)){c.qtip=b;c.removeAttribute("title");d.preventDefault();return{text:b}}else{a=this.tagConfig;c=d.getTarget("["+a.namespace+a.attribute+"]");if(c){return{target:c,text:c.getAttribute(a.namespace+a.attribute)}}}},onTargetOver:function(i){var k=this,j=i.getTarget(k.delegate),a,d,b,h,l,c,n,g,p,m,o;if(k.disabled){return}k.targetXY=i.getXY();if(!j||j.nodeType!==1||j==document.documentElement||j==document.body){return}if(k.activeTarget&&((j==k.activeTarget.el)||Ext.fly(k.activeTarget.el).contains(j))){k.clearTimer("hide");k.show();return}if(j){g=k.targets;for(o in g){if(g.hasOwnProperty(o)){m=g[o];p=Ext.fly(m.target);if(p&&(p.dom===j||p.contains(j))){b=p.dom;break}}}if(b){k.activeTarget=k.targets[b.id];k.activeTarget.el=j;k.anchor=k.activeTarget.anchor;if(k.anchor){k.anchorTarget=j}a=Ext.isDefined(k.activeTarget.showDelay);if(a){d=k.showDelay;k.showDelay=k.activeTarget.showDelay}k.delayShow();if(a){k.showDelay=d}return}}b=Ext.fly(j,"_quicktip-target");h=k.tagConfig;l=h.namespace;c=k.getTipCfg(i);if(c){if(c.target){j=c.target;b=Ext.fly(j,"_quicktip-target")}n=b.getAttribute(l+h.hide);k.activeTarget={el:j,text:c.text,width:+b.getAttribute(l+h.width)||null,autoHide:n!="user"&&n!=="false",title:b.getAttribute(l+h.title),cls:b.getAttribute(l+h.cls),align:b.getAttribute(l+h.align)};k.anchor=b.getAttribute(l+h.anchor);if(k.anchor){k.anchorTarget=j}a=Ext.isDefined(k.activeTarget.showDelay);if(a){d=k.showDelay;k.showDelay=k.activeTarget.showDelay}k.delayShow();if(a){k.showDelay=d}}},onTargetOut:function(g){var c=this,d=c.activeTarget,a,b;if(d&&g.within(c.activeTarget.el)&&!c.getTipCfg(g)){return}c.clearTimer("show");delete c.activeTarget;if(c.autoHide!==false){a=d&&Ext.isDefined(d.hideDelay);if(a){b=c.hideDelay;c.hideDelay=d.hideDelay}c.delayHide();if(a){c.hideDelay=b}}},showAt:function(d){var b=this,c=b.activeTarget,a;if(c){if(!b.rendered){b.render(Ext.getBody());b.activeTarget=c}b.suspendLayouts();if(c.title){b.setTitle(c.title);b.header.show()}else{b.header.hide()}b.update(c.text);b.autoHide=c.autoHide;b.dismissDelay=c.dismissDelay||b.dismissDelay;if(c.mouseOffset){d[0]+=c.mouseOffset[0];d[1]+=c.mouseOffset[1]}a=b.lastCls;if(a){b.removeCls(a);delete b.lastCls}a=c.cls;if(a){b.addCls(a);b.lastCls=a}b.setWidth(c.width);if(b.anchor){b.constrainPosition=false}else{if(c.align){d=b.el.getAlignToXY(c.el,c.align);b.constrainPosition=false}else{b.constrainPosition=true}}b.resumeLayouts(true)}b.callParent([d])},hide:function(){delete this.activeTarget;this.callParent()}});Ext.define("Ext.tip.QuickTipManager",(function(){var b,a=false;return{requires:["Ext.tip.QuickTip"],singleton:true,alternateClassName:"Ext.QuickTips",init:function(g,d){if(!b){if(!Ext.isReady){Ext.onReady(function(){Ext.tip.QuickTipManager.init(g,d)});return}var c=Ext.apply({disabled:a,id:"ext-quicktips-tip"},d),e=c.className,h=c.xtype;if(e){delete c.className}else{if(h){e="widget."+h;delete c.xtype}}if(g!==false){c.renderTo=document.body}b=Ext.create(e||"Ext.tip.QuickTip",c)}},destroy:function(){if(b){var c;b.destroy();b=c}},ddDisable:function(){if(b&&!a){b.disable()}},ddEnable:function(){if(b&&!a){b.enable()}},enable:function(){if(b){b.enable()}a=false},disable:function(){if(b){b.disable()}a=true},isEnabled:function(){return b!==undefined&&!b.disabled},getQuickTip:function(){return b},register:function(){b.register.apply(b,arguments)},unregister:function(){b.unregister.apply(b,arguments)},tips:function(){b.register.apply(b,arguments)}}}()));Ext.define("Ext.app.EventBus",{requires:["Ext.util.Event","Ext.Component"],mixins:{observable:"Ext.util.Observable"},constructor:function(){this.mixins.observable.constructor.call(this);this.bus={};var a=this;Ext.override(Ext.Component,{fireEvent:function(b){if(Ext.util.Observable.prototype.fireEvent.apply(this,arguments)!==false){return a.dispatch.call(a,b,this,arguments)}return false}})},dispatch:function(l,g,k){var h=this.bus,m=h[l],d,c,b,n,a,e,j;if(m){for(d in m){if(m.hasOwnProperty(d)&&g.is(d)){c=m[d];for(b in c){if(c.hasOwnProperty(b)){n=c[b];for(e=0,j=n.length;e<j;e++){a=n[e];if(a.fire.apply(a,Array.prototype.slice.call(k,1))===false){return false}}}}}}}return true},control:function(l,j,e){var h=this.bus,i,o,g,d,n,c,m,a,b,k;if(Ext.isString(l)){d=l;l={};l[d]=j;this.control(l,null,e);return}i=Ext.util.Observable.HasListeners.prototype;for(d in l){if(l.hasOwnProperty(d)){b=l[d]||{};for(k in b){if(b.hasOwnProperty(k)){n={};c=b[k];m=e;a=new Ext.util.Event(e,k);if(Ext.isObject(c)){n=c;c=n.fn;m=n.scope||e;delete n.fn;delete n.scope}a.addListener(c,m,n);i[k]=1;o=h[k]||(h[k]={});o=o[d]||(o[d]={});g=o[e.id]||(o[e.id]=[]);g.push(a)}}}}}});Ext.define("Ext.app.Application",{extend:"Ext.app.Controller",requires:["Ext.ModelManager","Ext.data.Model","Ext.data.StoreManager","Ext.tip.QuickTipManager","Ext.ComponentManager","Ext.app.EventBus"],scope:undefined,enableQuickTips:true,appFolder:"app",autoCreateViewport:false,constructor:function(b){b=b||{};Ext.apply(this,b);var g=this,l=b.requires||[],a,e,c,d,k,j,h;Ext.Loader.setPath(g.name,g.appFolder);if(g.paths){k=g.paths;for(h in k){if(k.hasOwnProperty(h)){j=k[h];Ext.Loader.setPath(h,j)}}}g.callParent(arguments);g.eventbus=new Ext.app.EventBus;a=Ext.Array.from(g.controllers);e=a&&a.length;g.controllers=new Ext.util.MixedCollection();if(g.autoCreateViewport){l.push(g.getModuleClassName("Viewport","view"))}for(c=0;c<e;c++){l.push(g.getModuleClassName(a[c],"controller"))}Ext.require(l);Ext.onReady(function(){g.init(g);for(c=0;c<e;c++){d=g.getController(a[c]);d.init(g)}g.onBeforeLaunch.call(g)},g)},control:function(b,c,a){this.eventbus.control(b,c,a)},launch:Ext.emptyFn,onBeforeLaunch:function(){var b=this,e,g,d,a;if(b.enableQuickTips){Ext.tip.QuickTipManager.init()}if(b.autoCreateViewport){b.getView("Viewport").create()}b.launch.call(this.scope||this);b.launched=true;b.fireEvent("launch",this);e=b.controllers.items;d=e.length;for(g=0;g<d;g++){a=e[g];a.onLaunch(this)}},getModuleClassName:function(a,b){if(a.indexOf(".")!==-1&&(Ext.ClassManager.isCreated(a)||Ext.Loader.isAClassNameWithAKnownPrefix(a))){return a}else{return this.name+"."+b+"."+a}},getController:function(b){var a=this.controllers.get(b);if(!a){a=Ext.create(this.getModuleClassName(b,"controller"),{application:this,id:b});this.controllers.add(a)}return a},getStore:function(b){var a=Ext.StoreManager.get(b);if(!a){a=Ext.create(this.getModuleClassName(b,"store"),{storeId:b})}return a},getModel:function(a){a=this.getModuleClassName(a,"model");return Ext.ModelManager.getModel(a)},getView:function(a){a=this.getModuleClassName(a,"view");return Ext.ClassManager.get(a)}});Ext.define("Ext.button.Split",{alias:"widget.splitbutton",extend:"Ext.button.Button",alternateClassName:"Ext.SplitButton",arrowCls:"split",split:true,initComponent:function(){this.callParent();this.addEvents("arrowclick")},setArrowHandler:function(b,a){this.arrowHandler=b;this.scope=a},onClick:function(c,a){var b=this;c.preventDefault();if(!b.disabled){if(b.overMenuTrigger){b.maybeShowMenu();b.fireEvent("arrowclick",b,c);if(b.arrowHandler){b.arrowHandler.call(b.scope||b,b,c)}}else{b.doToggle();b.fireHandler(c)}}}});Ext.define("Ext.button.Cycle",{alias:"widget.cycle",extend:"Ext.button.Split",alternateClassName:"Ext.CycleButton",getButtonText:function(b){var a=this,c="";if(b&&a.showText===true){if(a.prependText){c+=a.prependText}c+=b.text;return c}return a.text},setActiveItem:function(c,a){var b=this;if(!Ext.isObject(c)){c=b.menu.getComponent(c)}if(c){if(!b.rendered){b.text=b.getButtonText(c);b.iconCls=c.iconCls}else{b.setText(b.getButtonText(c));b.setIconCls(c.iconCls)}b.activeItem=c;if(!c.checked){c.setChecked(true,false)}if(b.forceIcon){b.setIconCls(b.forceIcon)}if(!a){b.fireEvent("change",b,c)}}},getActiveItem:function(){return this.activeItem},initComponent:function(){var g=this,e=0,b,c,a,d;g.addEvents("change");if(g.changeHandler){g.on("change",g.changeHandler,g.scope||g);delete g.changeHandler}b=(g.menu.items||[]).concat(g.items||[]);g.menu=Ext.applyIf({cls:Ext.baseCSSPrefix+"cycle-menu",items:[]},g.menu);a=b.length;for(c=0;c<a;c++){d=b[c];d=Ext.applyIf({group:g.id,itemIndex:c,checkHandler:g.checkHandler,scope:g,checked:d.checked||false},d);g.menu.items.push(d);if(d.checked){e=c}}g.itemCount=g.menu.items.length;g.callParent(arguments);g.on("click",g.toggleSelected,g);g.setActiveItem(e,g);if(g.width&&g.showText){g.addCls(Ext.baseCSSPrefix+"cycle-fixed-width")}},checkHandler:function(a,b){if(b){this.setActiveItem(a)}},toggleSelected:function(){var c=this,a=c.menu,b;b=c.activeItem.next(":not([disabled])")||a.items.getAt(0);b.setChecked(true)}});Ext.define("Ext.chart.Callout",{constructor:function(a){if(a.callouts){a.callouts.styles=Ext.applyIf(a.callouts.styles||{},{color:"#000",font:"11px Helvetica, sans-serif"});this.callouts=Ext.apply(this.callouts||{},a.callouts);this.calloutsArray=[]}},renderCallouts:function(){if(!this.callouts){return}var v=this,m=v.items,a=v.chart.animate,u=v.callouts,h=u.styles,e=v.calloutsArray,b=v.chart.store,s=b.getCount(),d=m.length/s,l=[],r,c,q,n,t,g,k,o;for(r=0,c=0;r<s;r++){for(q=0;q<d;q++){t=m[c];g=e[c];k=b.getAt(r);o=u.filter(k);if(!o&&!g){c++;continue}if(!g){e[c]=g=v.onCreateCallout(k,t,r,o,q,c)}for(n in g){if(g[n]&&g[n].setAttributes){g[n].setAttributes(h,true)}}if(!o){for(n in g){if(g[n]){if(g[n].setAttributes){g[n].setAttributes({hidden:true},true)}else{if(g[n].setVisible){g[n].setVisible(false)}}}}}u.renderer(g,k);v.onPlaceCallout(g,k,t,r,o,a,q,c,l);l.push(g);c++}}this.hideCallouts(c)},onCreateCallout:function(g,n,e,j){var k=this,l=k.calloutsGroup,d=k.callouts,o=d.styles,c=o.width,m=o.height,h=k.chart,b=h.surface,a={lines:false};a.lines=b.add(Ext.apply({},{type:"path",path:"M0,0",stroke:k.getLegendColor()||"#555"},o));if(d.items){a.panel=new Ext.Panel({style:"position: absolute;",width:c,height:m,items:d.items,renderTo:h.el})}return a},hideCallouts:function(b){var d=this.calloutsArray,a=d.length,e,c;while(a-->b){e=d[a];for(c in e){if(e[c]){e[c].hide(true)}}}}});Ext.define("Ext.layout.component.Draw",{alias:"layout.draw",extend:"Ext.layout.component.Auto",type:"draw",measureContentWidth:function(b){var c=b.target,a=b.getPaddingInfo(),d=this.getBBox(b);if(!c.viewBox){if(c.autoSize){return d.width+a.width}else{return d.x+d.width+a.width}}else{if(b.heightModel.shrinkWrap){return a.width}else{return d.width/d.height*(b.getProp("contentHeight")-a.height)+a.width}}},measureContentHeight:function(b){var c=b.target,a=b.getPaddingInfo(),d=this.getBBox(b);if(!b.target.viewBox){if(c.autoSize){return d.height+a.height}else{return d.y+d.height+a.height}}else{if(b.widthModel.shrinkWrap){return a.height}else{return d.height/d.width*(b.getProp("contentWidth")-a.width)+a.height}}},getBBox:function(a){var b=a.surfaceBBox;if(!b){b=a.target.surface.items.getBBox();if(b.width===-Infinity&&b.height===-Infinity){b.width=b.height=b.x=b.y=0}a.surfaceBBox=b}return b},publishInnerWidth:function(b,a){b.setContentWidth(a-b.getFrameInfo().width,true)},publishInnerHeight:function(b,a){b.setContentHeight(a-b.getFrameInfo().height,true)},finishedLayout:function(c){var b=c.props,a=c.getPaddingInfo();this.owner.setSurfaceSize(b.contentWidth-a.width,b.contentHeight-a.height);this.callParent(arguments)}});Ext.define("Ext.draw.CompositeSprite",{extend:"Ext.util.MixedCollection",mixins:{animate:"Ext.util.Animate"},autoDestroy:false,isCompositeSprite:true,constructor:function(a){var b=this;a=a||{};Ext.apply(b,a);b.addEvents("mousedown","mouseup","mouseover","mouseout","click");b.id=Ext.id(null,"ext-sprite-group-");b.callParent()},onClick:function(a){this.fireEvent("click",a)},onMouseUp:function(a){this.fireEvent("mouseup",a)},onMouseDown:function(a){this.fireEvent("mousedown",a)},onMouseOver:function(a){this.fireEvent("mouseover",a)},onMouseOut:function(a){this.fireEvent("mouseout",a)},attachEvents:function(b){var a=this;b.on({scope:a,mousedown:a.onMouseDown,mouseup:a.onMouseUp,mouseover:a.onMouseOver,mouseout:a.onMouseOut,click:a.onClick})},add:function(b,c){var a=this.callParent(arguments);this.attachEvents(a);return a},insert:function(a,b,c){return this.callParent(arguments)},remove:function(b){var a=this;b.un({scope:a,mousedown:a.onMouseDown,mouseup:a.onMouseUp,mouseover:a.onMouseOver,mouseout:a.onMouseOut,click:a.onClick});return a.callParent(arguments)},getBBox:function(){var e=0,n,j,k=this.items,g=this.length,h=Infinity,c=h,m=-h,b=h,l=-h,d,a;for(;e<g;e++){n=k[e];if(n.el&&!n.bboxExcluded){j=n.getBBox();c=Math.min(c,j.x);b=Math.min(b,j.y);m=Math.max(m,j.height+j.y);l=Math.max(l,j.width+j.x)}}return{x:c,y:b,height:m-b,width:l-c}},setAttributes:function(c,e){var d=0,b=this.items,a=this.length;for(;d<a;d++){b[d].setAttributes(c,e)}return this},hide:function(d){var c=0,b=this.items,a=this.length;for(;c<a;c++){b[c].hide(d)}return this},show:function(d){var c=0,b=this.items,a=this.length;for(;c<a;c++){b[c].show(d)}return this},redraw:function(){var e=this,d=0,c=e.items,b=e.getSurface(),a=e.length;if(b){for(;d<a;d++){b.renderItem(c[d])}}return e},setStyle:function(g){var c=0,b=this.items,a=this.length,e,d;for(;c<a;c++){e=b[c];d=e.el;if(d){d.setStyle(g)}}},addCls:function(e){var d=0,c=this.items,b=this.getSurface(),a=this.length;if(b){for(;d<a;d++){b.addCls(c[d],e)}}},removeCls:function(e){var d=0,c=this.items,b=this.getSurface(),a=this.length;if(b){for(;d<a;d++){b.removeCls(c[d],e)}}},getSurface:function(){var a=this.first();if(a){return a.surface}return null},destroy:function(){var d=this,a=d.getSurface(),c=d.autoDestroy,b;if(a){while(d.getCount()>0){b=d.first();d.remove(b);a.remove(b,c)}}d.clearListeners()}});Ext.define("Ext.draw.Surface",{mixins:{observable:"Ext.util.Observable"},requires:["Ext.draw.CompositeSprite"],uses:["Ext.draw.engine.Svg","Ext.draw.engine.Vml","Ext.draw.engine.SvgExporter","Ext.draw.engine.ImageExporter"],separatorRe:/[, ]+/,statics:{create:function(b,d){d=d||["Svg","Vml"];var c=0,a=d.length,e;for(;c<a;c++){if(Ext.supports[d[c]]!==false){return Ext.create("Ext.draw.engine."+d[c],b)}}return false},save:function(a,b){b=b||{};var e={"image/png":"Image","image/jpeg":"Image","image/svg+xml":"Svg"},d=e[b.type]||"Svg",c=Ext.draw.engine[d+"Exporter"];return c.generate(a,b)}},availableAttrs:{blur:0,"clip-rect":"0 0 1e9 1e9",cursor:"default",cx:0,cy:0,"dominant-baseline":"auto",fill:"none","fill-opacity":1,font:'10px "Arial"',"font-family":'"Arial"',"font-size":"10","font-style":"normal","font-weight":400,gradient:"",height:0,hidden:false,href:"http://sencha.com/",opacity:1,path:"M0,0",radius:0,rx:0,ry:0,scale:"1 1",src:"",stroke:"none","stroke-dasharray":"","stroke-linecap":"butt","stroke-linejoin":"butt","stroke-miterlimit":0,"stroke-opacity":1,"stroke-width":1,target:"_blank",text:"","text-anchor":"middle",title:"Ext Draw",width:0,x:0,y:0,zIndex:0},container:undefined,height:352,width:512,x:0,y:0,orderSpritesByZIndex:true,constructor:function(a){var b=this;a=a||{};Ext.apply(b,a);b.domRef=Ext.getDoc().dom;b.customAttributes={};b.addEvents("mousedown","mouseup","mouseover","mouseout","mousemove","mouseenter","mouseleave","click","dblclick");b.mixins.observable.constructor.call(b);b.getId();b.initGradients();b.initItems();if(b.renderTo){b.render(b.renderTo);delete b.renderTo}b.initBackground(a.background)},initSurface:Ext.emptyFn,renderItem:Ext.emptyFn,renderItems:Ext.emptyFn,setViewBox:function(b,d,c,a){if(isFinite(b)&&isFinite(d)&&isFinite(c)&&isFinite(a)){this.viewBox={x:b,y:d,width:c,height:a};this.applyViewBox()}},addCls:Ext.emptyFn,removeCls:Ext.emptyFn,setStyle:Ext.emptyFn,initGradients:function(){if(this.hasOwnProperty("gradients")){var a=this.gradients,d=a.length,b=this.addGradient,c;if(a){for(c=0;c<d;c++){if(b.call(this,a[c],c,d)===false){break}}}}},initItems:function(){var a=this.items;this.items=new Ext.draw.CompositeSprite();this.items.autoDestroy=true;this.groups=new Ext.draw.CompositeSprite();if(a){this.add(a)}},initBackground:function(b){var e=this,d=e.width,a=e.height,g,h,c;if(Ext.isString(b)){b={fill:b}}if(b){if(b.gradient){h=b.gradient;g=h.id;e.addGradient(h);e.background=e.add({type:"rect",x:0,y:0,width:d,height:a,fill:"url(#"+g+")",zIndex:-1})}else{if(b.fill){e.background=e.add({type:"rect",x:0,y:0,width:d,height:a,fill:b.fill,zIndex:-1})}else{if(b.image){e.background=e.add({type:"image",x:0,y:0,width:d,height:a,src:b.image,zIndex:-1})}}}e.background.bboxExcluded=true}},setSize:function(a,b){this.applyViewBox()},scrubAttrs:function(d){var c,b={},a={},e=d.attr;for(c in e){if(this.translateAttrs.hasOwnProperty(c)){b[this.translateAttrs[c]]=e[c];a[this.translateAttrs[c]]=true}else{if(this.availableAttrs.hasOwnProperty(c)&&!a[c]){b[c]=e[c]}}}return b},onClick:function(a){this.processEvent("click",a)},onDblClick:function(a){this.processEvent("dblclick",a)},onMouseUp:function(a){this.processEvent("mouseup",a)},onMouseDown:function(a){this.processEvent("mousedown",a)},onMouseOver:function(a){this.processEvent("mouseover",a)},onMouseOut:function(a){this.processEvent("mouseout",a)},onMouseMove:function(a){this.fireEvent("mousemove",a)},onMouseEnter:Ext.emptyFn,onMouseLeave:Ext.emptyFn,addGradient:Ext.emptyFn,add:function(){var g=Array.prototype.slice.call(arguments),j,d,a=g.length>1,h,b,c,e,k;if(a||Ext.isArray(g[0])){h=a?g:g[0];b=[];for(c=0,e=h.length;c<e;c++){k=h[c];k=this.add(k);b.push(k)}return b}j=this.prepareItems(g[0],true)[0];this.insertByZIndex(j);this.onAdd(j);return j},insertByZIndex:function(j){var g=this,d=g.items.items,c=d.length,k=Math.ceil,h=j.attr.zIndex,i=c,b=i-1,e=0,a;if(g.orderSpritesByZIndex&&c&&h<d[b].attr.zIndex){while(e<=b){i=k((e+b)/2);a=d[i].attr.zIndex;if(a>h){b=i-1}else{if(a<h){e=i+1}else{break}}}while(i<c&&d[i].attr.zIndex<=h){i++}}g.items.insert(i,j);return i},onAdd:function(d){var g=d.group,b=d.draggable,a,e,c;if(g){a=[].concat(g);e=a.length;for(c=0;c<e;c++){g=a[c];this.getGroup(g).add(d)}delete d.group}if(b){d.initDraggable()}},remove:function(b,e){if(b){this.items.remove(b);var a=[].concat(this.groups.items),d=a.length,c;for(c=0;c<d;c++){a[c].remove(b)}b.onRemove();if(e===true){b.destroy()}}},removeAll:function(d){var a=this.items.items,c=a.length,b;for(b=c-1;b>-1;b--){this.remove(a[b],d)}},onRemove:Ext.emptyFn,onDestroy:Ext.emptyFn,applyViewBox:function(){var d=this,l=d.viewBox,a=d.width||1,h=d.height||1,g,e,j,b,i,c,k;if(l&&(a||h)){g=l.x;e=l.y;j=l.width;b=l.height;i=h/b;c=a/j;k=Math.min(c,i);if(j*k<a){g-=(a-j*k)/2/k}if(b*k<h){e-=(h-b*k)/2/k}d.viewBoxShift={dx:-g,dy:-e,scale:k};if(d.background){d.background.setAttributes(Ext.apply({},{x:g,y:e,width:a/k,height:h/k},{hidden:false}),true)}}else{if(d.background&&a&&h){d.background.setAttributes(Ext.apply({x:0,y:0,width:a,height:h},{hidden:false}),true)}}},getBBox:function(a,b){var c=this["getPath"+a.type](a);if(b){a.bbox.plain=a.bbox.plain||Ext.draw.Draw.pathDimensions(c);return a.bbox.plain}if(a.dirtyTransform){this.applyTransformations(a,true)}a.bbox.transform=a.bbox.transform||Ext.draw.Draw.pathDimensions(Ext.draw.Draw.mapPath(c,a.matrix));return a.bbox.transform},transformToViewBox:function(a,d){if(this.viewBoxShift){var c=this,b=c.viewBoxShift;return[a/b.scale-b.dx,d/b.scale-b.dy]}else{return[a,d]}},applyTransformations:function(b,d){if(b.type=="text"){b.bbox.transform=0;this.transform(b,false)}b.dirtyTransform=false;var c=this,a=b.attr;if(a.translation.x!=null||a.translation.y!=null){c.translate(b)}if(a.scaling.x!=null||a.scaling.y!=null){c.scale(b)}if(a.rotation.degrees!=null){c.rotate(b)}b.bbox.transform=0;this.transform(b,d);b.transformations=[]},rotate:function(a){var e,b=a.attr.rotation.degrees,d=a.attr.rotation.x,c=a.attr.rotation.y;if(!Ext.isNumber(d)||!Ext.isNumber(c)){e=this.getBBox(a,true);d=!Ext.isNumber(d)?e.x+e.width/2:d;c=!Ext.isNumber(c)?e.y+e.height/2:c}a.transformations.push({type:"rotate",degrees:b,x:d,y:c})},translate:function(b){var a=b.attr.translation.x||0,c=b.attr.translation.y||0;b.transformations.push({type:"translate",x:a,y:c})},scale:function(b){var e,a=b.attr.scaling.x||1,g=b.attr.scaling.y||1,d=b.attr.scaling.centerX,c=b.attr.scaling.centerY;if(!Ext.isNumber(d)||!Ext.isNumber(c)){e=this.getBBox(b,true);d=!Ext.isNumber(d)?e.x+e.width/2:d;c=!Ext.isNumber(c)?e.y+e.height/2:c}b.transformations.push({type:"scale",x:a,y:g,centerX:d,centerY:c})},rectPath:function(a,e,b,c,d){if(d){return[["M",a+d,e],["l",b-d*2,0],["a",d,d,0,0,1,d,d],["l",0,c-d*2],["a",d,d,0,0,1,-d,d],["l",d*2-b,0],["a",d,d,0,0,1,-d,-d],["l",0,d*2-c],["a",d,d,0,0,1,d,-d],["z"]]}return[["M",a,e],["l",b,0],["l",0,c],["l",-b,0],["z"]]},ellipsePath:function(a,d,c,b){if(b==null){b=c}return[["M",a,d],["m",0,-b],["a",c,b,0,1,1,0,2*b],["a",c,b,0,1,1,0,-2*b],["z"]]},getPathpath:function(a){return a.attr.path},getPathcircle:function(c){var b=c.attr;return this.ellipsePath(b.x,b.y,b.radius,b.radius)},getPathellipse:function(c){var b=c.attr;return this.ellipsePath(b.x,b.y,b.radiusX||(b.width/2)||0,b.radiusY||(b.height/2)||0)},getPathrect:function(c){var b=c.attr;return this.rectPath(b.x||0,b.y||0,b.width||0,b.height||0,b.r||0)},getPathimage:function(c){var b=c.attr;return this.rectPath(b.x||0,b.y||0,b.width,b.height)},getPathtext:function(a){var b=this.getBBoxText(a);return this.rectPath(b.x,b.y,b.width,b.height)},createGroup:function(b){var a=this.groups.get(b);if(!a){a=new Ext.draw.CompositeSprite({surface:this});a.id=b||Ext.id(null,"ext-surface-group-");this.groups.add(a)}return a},getGroup:function(b){var a;if(typeof b=="string"){a=this.groups.get(b);if(!a){a=this.createGroup(b)}}else{a=b}return a},prepareItems:function(a,c){a=[].concat(a);var e,b,d;for(b=0,d=a.length;b<d;b++){e=a[b];if(!(e instanceof Ext.draw.Sprite)){e.surface=this;a[b]=this.createItem(e)}else{e.surface=this}}return a},setText:Ext.emptyFn,createItem:Ext.emptyFn,getId:function(){return this.id||(this.id=Ext.id(null,"ext-surface-"))},destroy:function(){var a=this;delete a.domRef;if(a.background){a.background.destroy()}a.removeAll(true);Ext.destroy(a.groups.items)}});Ext.define("Ext.draw.Component",{alias:"widget.draw",extend:"Ext.Component",requires:["Ext.draw.Surface","Ext.layout.component.Draw"],enginePriority:["Svg","Vml"],baseCls:Ext.baseCSSPrefix+"surface",componentLayout:"draw",viewBox:true,shrinkWrap:3,autoSize:false,initComponent:function(){this.callParent(arguments);this.addEvents("mousedown","mouseup","mousemove","mouseenter","mouseleave","click","dblclick")},onRender:function(){var d=this,j=d.viewBox,b=d.autoSize,h,c,a,i,g,e;d.callParent(arguments);if(d.createSurface()!==false){c=d.surface.items;if(j||b){h=c.getBBox();a=h.width;i=h.height;g=h.x;e=h.y;if(d.viewBox){d.surface.setViewBox(g,e,a,i)}else{d.autoSizeSurface()}}}},autoSizeSurface:function(){var a=this.surface.items.getBBox();this.setSurfaceSize(a.width,a.height)},setSurfaceSize:function(b,a){this.surface.setSize(b,a);if(this.autoSize){var c=this.surface.items.getBBox();this.surface.setViewBox(c.x,c.y-(+Ext.isOpera),b,a)}},createSurface:function(){var d=this,b=Ext.applyIf({renderTo:d.el,height:d.height,width:d.width,items:d.items},d.initialConfig),a;delete b.listeners;a=Ext.draw.Surface.create(b);if(!a){return false}d.surface=a;function c(e){return function(g){d.fireEvent(e,g)}}a.on({scope:d,mouseup:c("mouseup"),mousedown:c("mousedown"),mousemove:c("mousemove"),mouseenter:c("mouseenter"),mouseleave:c("mouseleave"),click:c("click"),dblclick:c("dblclick")})},onDestroy:function(){Ext.destroy(this.surface);this.callParent(arguments)}});Ext.define("Ext.chart.Shape",{singleton:true,circle:function(a,b){return a.add(Ext.apply({type:"circle",x:b.x,y:b.y,stroke:null,radius:b.radius},b))},line:function(a,b){return a.add(Ext.apply({type:"rect",x:b.x-b.radius,y:b.y-b.radius,height:2*b.radius,width:2*b.radius/5},b))},square:function(a,b){return a.add(Ext.applyIf({type:"rect",x:b.x-b.radius,y:b.y-b.radius,height:2*b.radius,width:2*b.radius,radius:null},b))},triangle:function(a,b){b.radius*=1.75;return a.add(Ext.apply({type:"path",stroke:null,path:"M".concat(b.x,",",b.y,"m0-",b.radius*0.58,"l",b.radius*0.5,",",b.radius*0.87,"-",b.radius,",0z")},b))},diamond:function(a,c){var b=c.radius;b*=1.5;return a.add(Ext.apply({type:"path",stroke:null,path:["M",c.x,c.y-b,"l",b,b,-b,b,-b,-b,b,-b,"z"]},c))},cross:function(a,c){var b=c.radius;b=b/1.7;return a.add(Ext.apply({type:"path",stroke:null,path:"M".concat(c.x-b,",",c.y,"l",[-b,-b,b,-b,b,b,b,-b,b,b,-b,b,b,b,-b,b,-b,-b,-b,b,-b,-b,"z"])},c))},plus:function(a,c){var b=c.radius/1.3;return a.add(Ext.apply({type:"path",stroke:null,path:"M".concat(c.x-b/2,",",c.y-b/2,"l",[0,-b,b,0,0,b,b,0,0,b,-b,0,0,b,-b,0,0,-b,-b,0,0,-b,"z"])},c))},arrow:function(a,c){var b=c.radius;return a.add(Ext.apply({type:"path",path:"M".concat(c.x-b*0.7,",",c.y-b*0.4,"l",[b*0.6,0,0,-b*0.4,b,b*0.8,-b,b*0.8,0,-b*0.4,-b*0.6,0],"z")},c))},drop:function(b,a,g,e,c,d){c=c||30;d=d||0;b.add({type:"path",path:["M",a,g,"l",c,0,"A",c*0.4,c*0.4,0,1,0,a+c*0.7,g-c*0.7,"z"],fill:"#000",stroke:"none",rotate:{degrees:22.5-d,x:a,y:g}});d=(d+90)*Math.PI/180;b.add({type:"text",x:a+c*Math.sin(d)-10,y:g+c*Math.cos(d)+5,text:e,"font-size":c*12/40,stroke:"none",fill:"#fff"})}});Ext.define("Ext.chart.LegendItem",{extend:"Ext.draw.CompositeSprite",requires:["Ext.chart.Shape"],x:0,y:0,zIndex:500,boldRe:/bold\s\d{1,}.*/i,constructor:function(a){this.callParent(arguments);this.createLegend(a)},createLegend:function(s){var t=this,i=s.yFieldIndex,l=t.series,a=l.type,m=t.yFieldIndex,d=t.legend,p=t.surface,q=d.x+t.x,n=d.y+t.y,c,k=t.zIndex,b,j,r,e,o=false,h=Ext.apply(l.seriesStyle,l.style);function g(u){var v=l[u];return(Ext.isArray(v)?v[m]:v)}j=t.add("label",p.add({type:"text",x:20,y:0,zIndex:(k||0)+2,fill:d.labelColor,font:d.labelFont,text:g("title")||g("yField"),style:{cursor:"pointer"}}));if(a==="line"||a==="scatter"){if(a==="line"){t.add("line",p.add({type:"path",path:"M0.5,0.5L16.5,0.5",zIndex:(k||0)+2,"stroke-width":l.lineWidth,"stroke-linejoin":"round","stroke-dasharray":l.dash,stroke:h.stroke||l.getLegendColor(i)||"#000",style:{cursor:"pointer"}}))}if(l.showMarkers||a==="scatter"){b=Ext.apply(l.markerStyle,l.markerConfig||{},{fill:l.getLegendColor(i)});t.add("marker",Ext.chart.Shape[b.type](p,{fill:b.fill,x:8.5,y:0.5,zIndex:(k||0)+2,radius:b.radius||b.size,style:{cursor:"pointer"}}))}}else{t.add("box",p.add({type:"rect",zIndex:(k||0)+2,x:0,y:0,width:12,height:12,fill:l.getLegendColor(i),style:{cursor:"pointer"}}))}t.setAttributes({hidden:false},true);c=t.getBBox();r=t.add("mask",p.add({type:"rect",x:c.x,y:c.y,width:c.width||20,height:c.height||20,zIndex:(k||0)+1,fill:t.legend.boxFill,style:{cursor:"pointer"}}));t.on("mouseover",function(){j.setStyle({"font-weight":"bold"});r.setStyle({cursor:"pointer"});l._index=i;l.highlightItem()},t);t.on("mouseout",function(){j.setStyle({"font-weight":d.labelFont&&t.boldRe.test(d.labelFont)?"bold":"normal"});l._index=i;l.unHighlightItem()},t);if(!l.visibleInLegend(i)){o=true;j.setAttributes({opacity:0.5},true)}t.on("mousedown",function(){if(!o){l.hideAll(i);j.setAttributes({opacity:0.5},true)}else{l.showAll(i);j.setAttributes({opacity:1},true)}o=!o;t.legend.chart.redraw()},t);t.updatePosition({x:0,y:0})},updatePosition:function(c){var g=this,a=g.items,e=a.length,b=0,d;if(!c){c=g.legend}for(;b<e;b++){d=a[b];switch(d.type){case"text":d.setAttributes({x:20+c.x+g.x,y:c.y+g.y},true);break;case"rect":d.setAttributes({translate:{x:c.x+g.x,y:c.y+g.y-6}},true);break;default:d.setAttributes({translate:{x:c.x+g.x,y:c.y+g.y}},true)}}}});Ext.define("Ext.chart.Legend",{requires:["Ext.chart.LegendItem"],visible:true,update:true,position:"bottom",x:0,y:0,labelColor:"#000",labelFont:"12px Helvetica, sans-serif",boxStroke:"#000",boxStrokeWidth:1,boxFill:"#FFF",itemSpacing:10,padding:5,width:0,height:0,boxZIndex:100,constructor:function(a){var b=this;if(a){Ext.apply(b,a)}b.items=[];b.isVertical=("left|right|float".indexOf(b.position)!==-1);b.origX=b.x;b.origY=b.y},create:function(){var e=this,a=e.chart.series.items,c,d,b;e.createBox();if(e.rebuild!==false){e.createItems()}if(!e.created&&e.isDisplayed()){e.created=true;for(c=0,d=a.length;c<d;c++){b=a[c];b.on("titlechange",function(){e.create();e.updatePosition()})}}},isDisplayed:function(){return this.visible&&this.chart.series.findIndex("showInLegend",true)!==-1},createItems:function(){var H=this,s=H.chart,b=s.series.items,o,q,A=s.surface,u=H.items,r=H.padding,K=H.itemSpacing,m=2,E=0,z=0,h=0,G=0,d=H.isVertical,g=Math,e=g.floor,J=g.max,l=0,C=0,D=u?u.length:0,p,n,k,F,a,t,w,v,c,I,B;if(D){for(;C<D;C++){u[C].destroy()}}u.length=[];for(C=0,o=b.length;C<o;C++){q=b[C];if(q.showInLegend){v=[].concat(q.yField);for(B=0,I=v.length;B<I;B++){c=v[B];F=new Ext.chart.LegendItem({legend:this,series:q,surface:s.surface,yFieldIndex:B});a=F.getBBox();w=a.width;t=a.height;if(C+B===0){k=d?r+t/2:r}else{k=K/(d?2:1)}F.x=e(d?r:h+k);F.y=e(d?G+k:r+t/2);h+=w+k;G+=t+k;E=J(E,w);z=J(z,t);u.push(F)}}}H.width=e((d?E:h)+r*2);if(d&&u.length===1){m=1}H.height=e((d?G-m*k:z)+(r*2));H.itemHeight=z},getBBox:function(){var a=this;return{x:Math.round(a.x)-a.boxStrokeWidth/2,y:Math.round(a.y)-a.boxStrokeWidth/2,width:a.width,height:a.height}},createBox:function(){var b=this,a,c;if(b.boxSprite){b.boxSprite.destroy()}c=b.getBBox();if(isNaN(c.width)||isNaN(c.height)){b.boxSprite=false;return}a=b.boxSprite=b.chart.surface.add(Ext.apply({type:"rect",stroke:b.boxStroke,"stroke-width":b.boxStrokeWidth,fill:b.boxFill,zIndex:b.boxZIndex},c));a.redraw()},updatePosition:function(){var u=this,p=u.items,r,j,l,h,n=u.width||0,c=u.height||0,m=u.padding,o=u.chart,k=o.chartBBox,s=o.insetPadding,t=k.width-(s*2),d=k.height-(s*2),g=k.x+s,e=k.y+s,q=o.surface,b=Math.floor,a;if(u.isDisplayed()){switch(u.position){case"left":l=s;h=b(e+d/2-c/2);break;case"right":l=b(q.width-n)-s;h=b(e+d/2-c/2);break;case"top":l=b(g+t/2-n/2);h=s;break;case"bottom":l=b(g+t/2-n/2);h=b(q.height-c)-s;break;default:l=b(u.origX)+s;h=b(u.origY)+s}u.x=l;u.y=h;for(r=0,j=p.length;r<j;r++){p[r].updatePosition()}a=u.getBBox();if(isNaN(a.width)||isNaN(a.height)){if(u.boxSprite){u.boxSprite.hide(true)}}else{if(!u.boxSprite){u.createBox()}u.boxSprite.setAttributes(a,true);u.boxSprite.show(true)}}},toggle:function(b){var e=this,d=0,c=e.items,a=c.length;if(e.boxSprite){if(b){e.boxSprite.show(true)}else{e.boxSprite.hide(true)}}for(;d<a;++d){if(b){c[d].show(true)}else{c[d].hide(true)}}e.visible=b}});Ext.define("Ext.chart.theme.Theme",{requires:["Ext.draw.Color"],theme:"Base",themeAttrs:false,initTheme:function(e){var d=this,b=Ext.chart.theme,c,a;if(e){e=e.split(":");for(c in b){if(c==e[0]){a=e[1]=="gradients";d.themeAttrs=new b[c]({useGradients:a});if(a){d.gradients=d.themeAttrs.gradients}if(d.themeAttrs.background){d.background=d.themeAttrs.background}return}}}}},function(){(function(){Ext.chart.theme=function(c,b){c=c||{};var m=0,p=+new Date(),j,a,k,r,s,g,o,q,n=[],e,h;if(c.baseColor){e=Ext.draw.Color.fromString(c.baseColor);h=e.getHSL()[2];if(h<0.15){e=e.getLighter(0.3)}else{if(h<0.3){e=e.getLighter(0.15)}else{if(h>0.85){e=e.getDarker(0.3)}else{if(h>0.7){e=e.getDarker(0.15)}}}}c.colors=[e.getDarker(0.3).toString(),e.getDarker(0.15).toString(),e.toString(),e.getLighter(0.15).toString(),e.getLighter(0.3).toString()];delete c.baseColor}if(c.colors){a=c.colors.slice();s=b.markerThemes;r=b.seriesThemes;j=a.length;b.colors=a;for(;m<j;m++){k=a[m];o=s[m]||{};g=r[m]||{};o.fill=g.fill=o.stroke=g.stroke=k;s[m]=o;r[m]=g}b.markerThemes=s.slice(0,j);b.seriesThemes=r.slice(0,j)}for(q in b){if(q in c){if(Ext.isObject(c[q])&&Ext.isObject(b[q])){Ext.apply(b[q],c[q])}else{b[q]=c[q]}}}if(c.useGradients){a=b.colors||(function(){var d=[];for(m=0,r=b.seriesThemes,j=r.length;m<j;m++){d.push(r[m].fill||r[m].stroke)}return d}());for(m=0,j=a.length;m<j;m++){e=Ext.draw.Color.fromString(a[m]);if(e){k=e.getDarker(0.1).toString();e=e.toString();q="theme-"+e.substr(1)+"-"+k.substr(1)+"-"+p;n.push({id:q,angle:45,stops:{0:{color:e.toString()},100:{color:k.toString()}}});a[m]="url(#"+q+")"}}b.gradients=n;b.colors=a}Ext.apply(this,b)}}())});Ext.define("Ext.chart.theme.Base",{requires:["Ext.chart.theme.Theme"],constructor:function(a){Ext.chart.theme.call(this,a,{background:false,axis:{stroke:"#444","stroke-width":1},axisLabelTop:{fill:"#444",font:"12px Arial, Helvetica, sans-serif",spacing:2,padding:5,renderer:function(b){return b}},axisLabelRight:{fill:"#444",font:"12px Arial, Helvetica, sans-serif",spacing:2,padding:5,renderer:function(b){return b}},axisLabelBottom:{fill:"#444",font:"12px Arial, Helvetica, sans-serif",spacing:2,padding:5,renderer:function(b){return b}},axisLabelLeft:{fill:"#444",font:"12px Arial, Helvetica, sans-serif",spacing:2,padding:5,renderer:function(b){return b}},axisTitleTop:{font:"bold 18px Arial",fill:"#444"},axisTitleRight:{font:"bold 18px Arial",fill:"#444",rotate:{x:0,y:0,degrees:270}},axisTitleBottom:{font:"bold 18px Arial",fill:"#444"},axisTitleLeft:{font:"bold 18px Arial",fill:"#444",rotate:{x:0,y:0,degrees:270}},series:{"stroke-width":0},seriesLabel:{font:"12px Arial",fill:"#333"},marker:{stroke:"#555",radius:3,size:3},colors:["#94ae0a","#115fa6","#a61120","#ff8809","#ffd13e","#a61187","#24ad9a","#7c7474","#a66111"],seriesThemes:[{fill:"#115fa6"},{fill:"#94ae0a"},{fill:"#a61120"},{fill:"#ff8809"},{fill:"#ffd13e"},{fill:"#a61187"},{fill:"#24ad9a"},{fill:"#7c7474"},{fill:"#115fa6"},{fill:"#94ae0a"},{fill:"#a61120"},{fill:"#ff8809"},{fill:"#ffd13e"},{fill:"#a61187"},{fill:"#24ad9a"},{fill:"#7c7474"},{fill:"#a66111"}],markerThemes:[{fill:"#115fa6",type:"circle"},{fill:"#94ae0a",type:"cross"},{fill:"#115fa6",type:"plus"},{fill:"#94ae0a",type:"circle"},{fill:"#a61120",type:"cross"}]})}},function(){var c=["#b1da5a","#4ce0e7","#e84b67","#da5abd","#4d7fe6","#fec935"],k=["Green","Sky","Red","Purple","Blue","Yellow"],h=0,g=0,b=c.length,a=Ext.chart.theme,d=[["#f0a50a","#c20024","#2044ba","#810065","#7eae29"],["#6d9824","#87146e","#2a9196","#d39006","#1e40ac"],["#fbbc29","#ce2e4e","#7e0062","#158b90","#57880e"],["#ef5773","#fcbd2a","#4f770d","#1d3eaa","#9b001f"],["#7eae29","#fdbe2a","#910019","#27b4bc","#d74dbc"],["#44dce1","#0b2592","#996e05","#7fb325","#b821a1"]],e=d.length;for(;h<b;h++){a[k[h]]=(function(i){return Ext.extend(a.Base,{constructor:function(j){a.Base.prototype.constructor.call(this,Ext.apply({baseColor:i},j))}})}(c[h]))}for(h=0;h<e;h++){a["Category"+(h+1)]=(function(i){return Ext.extend(a.Base,{constructor:function(j){a.Base.prototype.constructor.call(this,Ext.apply({colors:i},j))}})}(d[h]))}});Ext.define("Ext.chart.MaskLayer",{extend:"Ext.Component",constructor:function(a){a=Ext.apply(a||{},{style:"position:absolute;background-color:#888;cursor:move;opacity:0.6;border:1px solid #222;"});this.callParent([a])},initComponent:function(){var a=this;a.callParent(arguments);a.addEvents("mousedown","mouseup","mousemove","mouseenter","mouseleave")},initDraggable:function(){this.callParent(arguments);this.dd.onStart=function(c){var b=this,a=b.comp;this.startPosition=a.getPosition(true);if(a.ghost&&!a.liveDrag){b.proxy=a.ghost();b.dragTarget=b.proxy.header.el}if(b.constrain||b.constrainDelegate){b.constrainTo=b.calculateConstrainRegion()}}}});Ext.define("Ext.chart.Mask",{requires:["Ext.chart.MaskLayer"],constructor:function(a){var c=this,b;c.addEvents("select");if(a){Ext.apply(c,a)}if(c.enableMask){c.on("afterrender",function(){var d=new Ext.chart.MaskLayer({renderTo:c.el,hidden:true});d.el.on({mousemove:function(g){c.onMouseMove(g)},mouseup:function(g){c.resized(g)}});b=new Ext.resizer.Resizer({el:d.el,handles:"all",pinned:true});b.on({resize:function(g){c.resized(g)}});d.initDraggable();c.maskType=c.mask;c.mask=d;c.maskSprite=c.surface.add({type:"path",path:["M",0,0],zIndex:1001,opacity:0.7,hidden:true,stroke:"#444"})},c,{single:true})}},resized:function(d){var g=this,l=g.bbox||g.chartBBox,j=l.x,i=l.y,a=l.width,m=l.height,c=g.mask.getBox(true),h=Math.max,b=Math.min,n=c.x-j,k=c.y-i;n=h(n,j);k=h(k,i);n=b(n,a);k=b(k,m);c.x=n;c.y=k;g.fireEvent("select",g,c)},onMouseUp:function(c){var a=this,d=a.bbox||a.chartBBox,b=a.maskSelection;a.maskMouseDown=false;a.mouseDown=false;if(a.mouseMoved){a.onMouseMove(c);a.mouseMoved=false;a.fireEvent("select",a,{x:b.x-d.x,y:b.y-d.y,width:b.width,height:b.height})}},onMouseDown:function(b){var a=this;a.mouseDown=true;a.mouseMoved=false;a.maskMouseDown={x:b.getPageX()-a.el.getX(),y:b.getPageY()-a.el.getY()}},onMouseMove:function(t){var u=this,o=u.maskType,a=u.bbox||u.chartBBox,i=a.x,h=a.y,b=Math,q=b.floor,j=b.abs,n=b.min,p=b.max,k=q(h+a.height),m=q(i+a.width),d=t.getPageX(),c=t.getPageY(),s=d-u.el.getX(),r=c-u.el.getY(),g=u.maskMouseDown,l;u.mouseMoved=u.mouseDown;s=p(s,i);r=p(r,h);s=n(s,m);r=n(r,k);if(g&&u.mouseDown){if(o=="horizontal"){r=h;g.y=k;c=u.el.getY()+a.height+u.insetPadding}else{if(o=="vertical"){s=i;g.x=m}}m=g.x-s;k=g.y-r;l=["M",s,r,"l",m,0,0,k,-m,0,"z"];u.maskSelection={x:m>0?s:s+m,y:k>0?r:r+k,width:j(m),height:j(k)};u.mask.updateBox(u.maskSelection);u.mask.show();u.maskSprite.setAttributes({hidden:true},true)}else{if(o=="horizontal"){l=["M",s,h,"L",s,k]}else{if(o=="vertical"){l=["M",i,r,"L",m,r]}else{l=["M",s,h,"L",s,k,"M",i,r,"L",m,r]}}u.maskSprite.setAttributes({path:l,fill:u.maskMouseDown?u.maskSprite.stroke:false,"stroke-width":o===true?1:3,hidden:false},true)}},onMouseLeave:function(b){var a=this;a.mouseMoved=false;a.mouseDown=false;a.maskMouseDown=false;a.mask.hide();a.maskSprite.hide(true)}});Ext.define("Ext.chart.Navigation",{constructor:function(){this.originalStore=this.store},setZoom:function(k){var j=this,g=j.axes,a=g.items,e,h,c,p=j.chartBBox,o=1/p.width,b=1/p.height,d={x:k.x*o,y:k.y*b,width:k.width*o,height:k.height*b},l,n,m;for(e=0,h=a.length;e<h;e++){c=a[e];l=c.calcEnds();if(c.position=="bottom"||c.position=="top"){n=(l.to-l.from)*d.x+l.from;m=(l.to-l.from)*d.width+n;c.minimum=n;c.maximum=m}else{m=(l.to-l.from)*(1-d.y)+l.from;n=m-(l.to-l.from)*d.height;c.minimum=n;c.maximum=m}}j.redraw(false)},restoreZoom:function(){if(this.originalStore){this.store=this.substore=this.originalStore;this.redraw(true)}}});Ext.define("Ext.chart.Chart",{alias:"widget.chart",extend:"Ext.draw.Component",mixins:{themeManager:"Ext.chart.theme.Theme",mask:"Ext.chart.Mask",navigation:"Ext.chart.Navigation",bindable:"Ext.util.Bindable",observable:"Ext.util.Observable"},uses:["Ext.chart.series.Series"],requires:["Ext.util.MixedCollection","Ext.data.StoreManager","Ext.chart.Legend","Ext.chart.theme.Base","Ext.chart.theme.Theme","Ext.util.DelayedTask"],viewBox:false,animate:false,legend:false,insetPadding:10,enginePriority:["Svg","Vml"],background:false,constructor:function(b){var c=this,a;b=Ext.apply({},b);c.initTheme(b.theme||c.theme);if(c.gradients){Ext.apply(b,{gradients:c.gradients})}if(c.background){Ext.apply(b,{background:c.background})}if(b.animate){a={easing:"ease",duration:500};if(Ext.isObject(b.animate)){b.animate=Ext.applyIf(b.animate,a)}else{b.animate=a}}c.mixins.observable.constructor.call(c,b);if(b.enableMask){c.mixins.mask.constructor.call(c)}c.mixins.navigation.constructor.call(c);c.callParent([b])},getChartStore:function(){return this.substore||this.store},initComponent:function(){var b=this,c,a;b.callParent();b.addEvents("itemmousedown","itemmouseup","itemmouseover","itemmouseout","itemclick","itemdblclick","itemdragstart","itemdrag","itemdragend","beforerefresh","refresh");Ext.applyIf(b,{zoom:{width:1,height:1,x:0,y:0}});b.maxGutter=[0,0];b.store=Ext.data.StoreManager.lookup(b.store);c=b.axes;b.axes=new Ext.util.MixedCollection(false,function(d){return d.position});if(c){b.axes.addAll(c)}a=b.series;b.series=new Ext.util.MixedCollection(false,function(d){return d.seriesId||(d.seriesId=Ext.id(null,"ext-chart-series-"))});if(a){b.series.addAll(a)}if(b.legend!==false){b.legend=new Ext.chart.Legend(Ext.applyIf({chart:b},b.legend))}b.on({mousemove:b.onMouseMove,mouseleave:b.onMouseLeave,mousedown:b.onMouseDown,mouseup:b.onMouseUp,click:b.onClick,dblclick:b.onDblClick,scope:b})},afterComponentLayout:function(b,a){var c=this;if(Ext.isNumber(b)&&Ext.isNumber(a)){if(b!==c.curWidth||a!==c.curHeight){c.curWidth=b;c.curHeight=a;c.redraw(true)}else{if(c.needsRedraw){delete c.needsRedraw;c.redraw()}}}this.callParent(arguments)},redraw:function(b){var h=this,g=h.series.items,d=g.length,a=h.axes.items,c=a.length,e,k=h.chartBBox={x:0,y:0,height:h.curHeight,width:h.curWidth},j=h.legend;h.surface.setSize(k.width,k.height);for(e=0;e<d;e++){h.initializeSeries(g[e],e)}for(e=0;e<c;e++){h.initializeAxis(a[e])}for(e=0;e<c;e++){a[e].processView()}for(e=0;e<c;e++){a[e].drawAxis(true)}if(j!==false&&j.visible){if(j.update||!j.created){j.create()}}h.alignAxes();if(j!==false&&j.visible){j.updatePosition()}h.getMaxGutter();h.resizing=!!b;for(e=0;e<c;e++){a[e].drawAxis()}for(e=0;e<d;e++){h.drawCharts(g[e])}h.resizing=false},afterRender:function(){var b,a=this;this.callParent();if(a.categoryNames){a.setCategoryNames(a.categoryNames)}if(a.tipRenderer){b=a.getFunctionRef(a.tipRenderer);a.setTipRenderer(b.fn,b.scope)}a.bindStore(a.store,true);a.refresh();if(a.surface.engine==="Vml"){a.on("added",a.onAddedVml,a);a.mon(Ext.container.Container.hierarchyEventSource,"added",a.onContainerAddedVml,a)}},onAddedVml:function(){this.needsRedraw=true},onContainerAddedVml:function(a){if(this.isDescendantOf(a)){this.needsRedraw=true}},getEventXY:function(d){var c=this,b=this.surface.getRegion(),h=d.getXY(),a=h[0]-b.left,g=h[1]-b.top;return[a,g]},onClick:function(a){this.handleClick("itemclick",a)},onDblClick:function(a){this.handleClick("itemdblclick",a)},handleClick:function(a,h){var k=this,g=k.getEventXY(h),d=k.series.items,b,j,c,l;for(b=0,j=d.length;b<j;b++){c=d[b];if(Ext.draw.Draw.withinBox(g[0],g[1],c.bbox)){if(c.getItemForPoint){l=c.getItemForPoint(g[0],g[1]);if(l){c.fireEvent(a,l)}}}}},onMouseDown:function(k){var j=this,a=j.getEventXY(k),b=j.series.items,d,h,c,g;if(j.enableMask){j.mixins.mask.onMouseDown.call(j,k)}for(d=0,h=b.length;d<h;d++){c=b[d];if(Ext.draw.Draw.withinBox(a[0],a[1],c.bbox)){if(c.getItemForPoint){g=c.getItemForPoint(a[0],a[1]);if(g){c.fireEvent("itemmousedown",g)}}}}},onMouseUp:function(k){var j=this,a=j.getEventXY(k),b=j.series.items,d,h,c,g;if(j.enableMask){j.mixins.mask.onMouseUp.call(j,k)}for(d=0,h=b.length;d<h;d++){c=b[d];if(Ext.draw.Draw.withinBox(a[0],a[1],c.bbox)){if(c.getItemForPoint){g=c.getItemForPoint(a[0],a[1]);if(g){c.fireEvent("itemmouseup",g)}}}}},onMouseMove:function(h){var k=this,d=k.getEventXY(h),c=k.series.items,a,j,b,n,l,g,m;if(k.enableMask){k.mixins.mask.onMouseMove.call(k,h)}for(a=0,j=c.length;a<j;a++){b=c[a];if(Ext.draw.Draw.withinBox(d[0],d[1],b.bbox)){if(b.getItemForPoint){n=b.getItemForPoint(d[0],d[1]);l=b._lastItemForPoint;g=b._lastStoreItem;m=b._lastStoreField;if(n!==l||n&&(n.storeItem!=g||n.storeField!=m)){if(l){b.fireEvent("itemmouseout",l);delete b._lastItemForPoint;delete b._lastStoreField;delete b._lastStoreItem}if(n){b.fireEvent("itemmouseover",n);b._lastItemForPoint=n;b._lastStoreItem=n.storeItem;b._lastStoreField=n.storeField}}}}else{l=b._lastItemForPoint;if(l){b.fireEvent("itemmouseout",l);delete b._lastItemForPoint;delete b._lastStoreField;delete b._lastStoreItem}}}},onMouseLeave:function(h){var g=this,a=g.series.items,c,d,b;if(g.enableMask){g.mixins.mask.onMouseLeave.call(g,h)}for(c=0,d=a.length;c<d;c++){b=a[c];delete b._lastItemForPoint}},delayRefresh:function(){var a=this;if(!a.refreshTask){a.refreshTask=new Ext.util.DelayedTask(a.refresh,a)}a.refreshTask.delay(a.refreshBuffer)},refresh:function(){var a=this;if(a.rendered&&a.curWidth!==undefined&&a.curHeight!==undefined){if(!a.isVisible(true)&&!a.refreshPending){a.setShowListeners("mon");a.refreshPending=true;return}if(a.fireEvent("beforerefresh",a)!==false){a.redraw();a.fireEvent("refresh",a)}}},onShow:function(){var a=this;a.callParent(arguments);if(a.refreshPending){a.delayRefresh();a.setShowListeners("mun")}delete a.refreshPending},setShowListeners:function(b){var a=this;a[b](Ext.container.Container.hierarchyEventSource,{scope:a,single:true,show:a.forceRefresh,expand:a.forceRefresh})},forceRefresh:function(a){var b=this;if(b.isDescendantOf(a)&&b.refreshPending){b.setShowListeners("mun");b.delayRefresh()}delete b.refreshPending},bindStore:function(a,b){var c=this;c.mixins.bindable.bindStore.apply(c,arguments);if(c.store&&!b){c.refresh()}},getStoreListeners:function(){var b=this.refresh,a=this.delayRefresh;return{refresh:b,add:a,remove:a,update:a,clear:b}},initializeAxis:function(b){var e=this,k=e.chartBBox,j=k.width,d=k.height,i=k.x,g=k.y,c=e.themeAttrs,a={chart:e};if(c){a.axisStyle=Ext.apply({},c.axis);a.axisLabelLeftStyle=Ext.apply({},c.axisLabelLeft);a.axisLabelRightStyle=Ext.apply({},c.axisLabelRight);a.axisLabelTopStyle=Ext.apply({},c.axisLabelTop);a.axisLabelBottomStyle=Ext.apply({},c.axisLabelBottom);a.axisTitleLeftStyle=Ext.apply({},c.axisTitleLeft);a.axisTitleRightStyle=Ext.apply({},c.axisTitleRight);a.axisTitleTopStyle=Ext.apply({},c.axisTitleTop);a.axisTitleBottomStyle=Ext.apply({},c.axisTitleBottom)}switch(b.position){case"top":Ext.apply(a,{length:j,width:d,x:i,y:g});break;case"bottom":Ext.apply(a,{length:j,width:d,x:i,y:d});break;case"left":Ext.apply(a,{length:d,width:j,x:i,y:d});break;case"right":Ext.apply(a,{length:d,width:j,x:j,y:d});break}if(!b.chart){Ext.apply(a,b);b=e.axes.replace(Ext.createByAlias("axis."+b.type.toLowerCase(),a))}else{Ext.apply(b,a)}},alignAxes:function(){var l=this,k=l.axes,a=k.items,e,p=l.legend,g=["top","right","bottom","left"],b,h,j,r,o=l.insetPadding,d={top:o,right:o,bottom:o,left:o},n,q,m;function c(t){var s=k.findIndex("position",t);return(s<0)?null:k.getAt(s)}for(h=0,j=g.length;h<j;h++){b=g[h];n=(b==="left"||b==="right");e=c(b);if(p!==false){if(p.position===b){q=p.getBBox();d[b]+=(n?q.width:q.height)+d[b]}}if(e&&e.bbox){q=e.bbox;d[b]+=(n?q.width:q.height)}}r={x:d.left,y:d.top,width:l.curWidth-d.left-d.right,height:l.curHeight-d.top-d.bottom};l.chartBBox=r;for(h=0,j=a.length;h<j;h++){e=a[h];m=e.position;n=(m==="left"||m==="right");e.x=(m==="right"?r.x+r.width:r.x);e.y=(m==="top"?r.y:r.y+r.height);e.width=(n?r.width:r.height);e.length=(n?r.height:r.width)}},initializeSeries:function(h,k){var j=this,d=j.themeAttrs,c,e,n,p,o,m=[],g=0,b,a={chart:j,seriesId:h.seriesId};if(d){n=d.seriesThemes;o=d.markerThemes;c=Ext.apply({},d.series);e=Ext.apply({},d.marker);a.seriesStyle=Ext.apply(c,n[k%n.length]);a.seriesLabelStyle=Ext.apply({},d.seriesLabel);a.markerStyle=Ext.apply(e,o[k%o.length]);if(d.colors){a.colorArrayStyle=d.colors}else{m=[];for(b=n.length;g<b;g++){p=n[g];if(p.fill||p.stroke){m.push(p.fill||p.stroke)}}if(m.length){a.colorArrayStyle=m}}a.seriesIdx=k}if(h instanceof Ext.chart.series.Series){Ext.apply(h,a)}else{Ext.applyIf(a,h);h=j.series.replace(Ext.createByAlias("series."+h.type.toLowerCase(),a))}if(h.initialize){h.initialize()}},getMaxGutter:function(){var g=this,a=g.series.items,d,e,c,b=[0,0],h;for(d=0,e=a.length;d<e;d++){c=a[d];h=c.getGutters&&c.getGutters()||[0,0];b[0]=Math.max(b[0],h[0]);b[1]=Math.max(b[1],h[1])}g.maxGutter=b},drawAxis:function(a){a.drawAxis()},drawCharts:function(a){a.triggerafterrender=false;a.drawSeries();if(!this.animate){a.fireEvent("afterrender")}},save:function(a){return Ext.draw.Surface.save(this.surface,a)},destroy:function(){Ext.destroy(this.surface);this.bindStore(null);this.callParent(arguments)}});Ext.define("Ext.chart.Highlight",{requires:["Ext.fx.Anim"],highlight:false,highlightCfg:{fill:"#fdd","stroke-width":5,stroke:"#f55"},constructor:function(a){if(a.highlight){if(a.highlight!==true){this.highlightCfg=Ext.merge(this.highlightCfg,a.highlight)}}},highlightItem:function(k){if(!k){return}var g=this,j=k.sprite,a=Ext.merge({},g.highlightCfg,g.highlight),d=g.chart.surface,c=g.chart.animate,b,i,h,e;if(!g.highlight||!j||j._highlighted){return}if(j._anim){j._anim.paused=true}j._highlighted=true;if(!j._defaults){j._defaults=Ext.apply({},j.attr);i={};h={};for(b in a){if(!(b in j._defaults)){j._defaults[b]=d.availableAttrs[b]}i[b]=j._defaults[b];h[b]=a[b];if(Ext.isObject(a[b])){i[b]={};h[b]={};Ext.apply(j._defaults[b],j.attr[b]);Ext.apply(i[b],j._defaults[b]);for(e in j._defaults[b]){if(!(e in a[b])){h[b][e]=i[b][e]}else{h[b][e]=a[b][e]}}for(e in a[b]){if(!(e in h[b])){h[b][e]=a[b][e]}}}}j._from=i;j._to=h;j._endStyle=h}if(c){j._anim=new Ext.fx.Anim({target:j,from:j._from,to:j._to,duration:150})}else{j.setAttributes(j._to,true)}},unHighlightItem:function(){if(!this.highlight||!this.items){return}var j=this,h=j.items,g=h.length,a=Ext.merge({},j.highlightCfg,j.highlight),c=j.chart.animate,e=0,d,b,k;for(;e<g;e++){if(!h[e]){continue}k=h[e].sprite;if(k&&k._highlighted){if(k._anim){k._anim.paused=true}d={};for(b in a){if(Ext.isObject(k._defaults[b])){d[b]={};Ext.apply(d[b],k._defaults[b])}else{d[b]=k._defaults[b]}}if(c){k._endStyle=d;k._anim=new Ext.fx.Anim({target:k,to:d,duration:150})}else{k.setAttributes(d,true)}delete k._highlighted}}},cleanHighlights:function(){if(!this.highlight){return}var d=this.group,c=this.markerGroup,b=0,a;for(a=d.getCount();b<a;b++){delete d.getAt(b)._defaults}if(c){for(a=c.getCount();b<a;b++){delete c.getAt(b)._defaults}}}});Ext.define("Ext.chart.Label",{requires:["Ext.draw.Color"],colorStringRe:/url\s*\(\s*#([^\/)]+)\s*\)/,constructor:function(a){var b=this;b.label=Ext.applyIf(b.label||{},{display:"none",color:"#000",field:"name",minMargin:50,font:"11px Helvetica, sans-serif",orientation:"horizontal",renderer:function(c){return c}});if(b.label.display!=="none"){b.labelsGroup=b.chart.surface.getGroup(b.seriesId+"-labels")}},renderLabels:function(){var o=this,L=o.chart,x=L.gradients,r=o.items,H=L.animate,A=o.label,u=A.display,v=A.color,d=[].concat(A.field),q=o.labelsGroup,l=(q||0)&&q.length,b=o.chart.getChartStore(),p=b.getCount(),h=(r||0)&&r.length,D=h/p,z=(x||0)&&x.length,m=Ext.draw.Color,K=[],n,J,E,c,y,I,G,e,g,t,w,F,M,s,N,C,B,a;if(u=="none"){return}if(h==0){while(l--){K.push(l)}}else{for(J=0,E=0,c=0;J<p;J++){y=0;for(I=0;I<D;I++){w=r[E];F=q.getAt(c);M=b.getAt(J);while(this.__excludes&&this.__excludes[y]){y++}if(!w&&F){F.hide(true);c++}if(w&&d[I]){if(!F){F=o.onCreateLabel(M,w,J,u,I,y)}o.onPlaceLabel(F,M,w,J,u,H,I,y);c++;if(A.contrast&&w.sprite){s=w.sprite;if(s._endStyle){a=s._endStyle.fill}else{if(s._to){a=s._to.fill}else{a=s.attr.fill}}a=a||s.attr.fill;N=m.fromString(a);if(a&&!N){a=a.match(o.colorStringRe)[1];for(G=0;G<z;G++){n=x[G];if(n.id==a){t=0;e=0;for(g in n.stops){t++;e+=m.fromString(n.stops[g].color).getGrayscale()}C=(e/t)/255;break}}}else{C=N.getGrayscale()/255}if(F.isOutside){C=1}B=m.fromString(F.attr.color||F.attr.fill).getHSL();B[2]=C>0.5?0.2:0.8;F.setAttributes({fill:String(m.fromHSL.apply({},B))},true)}}E++;y++}}l=q.length;while(l>c){K.push(c);c++}}o.hideLabels(K)},hideLabels:function(b){var a=this.labelsGroup,c=!!b&&b.length;if(!a){return}if(c===false){c=a.getCount();while(c--){a.getAt(c).hide(true)}}else{while(c--){a.getAt(b[c]).hide(true)}}}});Ext.define("Ext.chart.TipSurface",{extend:"Ext.draw.Component",spriteArray:false,renderFirst:true,constructor:function(a){this.callParent([a]);if(a.sprites){this.spriteArray=[].concat(a.sprites);delete a.sprites}},onRender:function(){var c=this,b=0,a=0,d,e;this.callParent(arguments);e=c.spriteArray;if(c.renderFirst&&e){c.renderFirst=false;for(a=e.length;b<a;b++){d=c.surface.add(e[b]);d.setAttributes({hidden:false},true)}}}});Ext.define("Ext.chart.Tip",{requires:["Ext.tip.ToolTip","Ext.chart.TipSurface"],constructor:function(b){var c=this,a,d,e;if(b.tips){c.tipTimeout=null;c.tipConfig=Ext.apply({},b.tips,{renderer:Ext.emptyFn,constrainPosition:true,autoHide:true});c.tooltip=new Ext.tip.ToolTip(c.tipConfig);c.chart.surface.on("mousemove",c.tooltip.onMouseMove,c.tooltip);c.chart.surface.on("mouseleave",function(){c.hideTip()});if(c.tipConfig.surface){a=c.tipConfig.surface;d=a.sprites;e=new Ext.chart.TipSurface({id:"tipSurfaceComponent",sprites:d});if(a.width&&a.height){e.setSize(a.width,a.height)}c.tooltip.add(e);c.spriteTip=e}}},showTip:function(l){var e=this,m,a,c,d,k,b,j,h,i,g;if(!e.tooltip){return}clearTimeout(e.tipTimeout);m=e.tooltip;a=e.spriteTip;c=e.tipConfig;d=m.trackMouse;if(!d){m.trackMouse=true;k=l.sprite;b=k.surface;j=Ext.get(b.getId());if(j){h=j.getXY();i=h[0]+(k.attr.x||0)+(k.attr.translation&&k.attr.translation.x||0);g=h[1]+(k.attr.y||0)+(k.attr.translation&&k.attr.translation.y||0);m.targetXY=[i,g]}}if(a){c.renderer.call(m,l.storeItem,l,a.surface)}else{c.renderer.call(m,l.storeItem,l)}m.show();m.trackMouse=d},hideTip:function(a){var b=this.tooltip;if(!b){return}clearTimeout(this.tipTimeout);this.tipTimeout=setTimeout(function(){b.hide()},0)}});Ext.define("Ext.chart.axis.Abstract",{requires:["Ext.chart.Chart"],constructor:function(a){a=a||{};var b=this,c=a.position||"left";c=c.charAt(0).toUpperCase()+c.substring(1);a.label=Ext.apply(a["axisLabel"+c+"Style"]||{},a.label||{});a.axisTitleStyle=Ext.apply(a["axisTitle"+c+"Style"]||{},a.labelTitle||{});Ext.apply(b,a);b.fields=Ext.Array.from(b.fields);this.callParent();b.labels=[];b.getId();b.labelGroup=b.chart.surface.getGroup(b.axisId+"-labels")},alignment:null,grid:false,steps:10,x:0,y:0,minValue:0,maxValue:0,getId:function(){return this.axisId||(this.axisId=Ext.id(null,"ext-axis-"))},processView:Ext.emptyFn,drawAxis:Ext.emptyFn,addDisplayAndLabels:Ext.emptyFn});Ext.define("Ext.chart.axis.Axis",{extend:"Ext.chart.axis.Abstract",alternateClassName:"Ext.chart.Axis",requires:["Ext.draw.Draw"],forceMinMax:false,dashSize:3,position:"bottom",skipFirst:false,length:0,width:0,adjustEnd:true,majorTickSteps:false,applyData:Ext.emptyFn,getRange:function(){var C=this,p=C.chart,l=p.getChartStore(),E=l.data.items,o=p.series.items,D=C.position,q,a=Ext.chart.series,v=[],u=Infinity,y=-Infinity,c=C.position==="left"||C.position==="right",z,n,d,x,w,m=E.length,g,B={},t={},A=true,r,h,e,b,s;r=C.fields;for(x=0,n=r.length;x<n;x++){t[r[x]]=true}for(z=0,n=o.length;z<n;z++){if(o[z].seriesIsHidden){continue}if(!o[z].getAxesForXAndYFields){continue}q=o[z].getAxesForXAndYFields();if(q.xAxis&&q.xAxis!==D&&q.yAxis&&q.yAxis!==D){continue}if(a.Bar&&o[z] instanceof a.Bar&&!o[z].column){r=c?Ext.Array.from(o[z].xField):Ext.Array.from(o[z].yField)}else{r=c?Ext.Array.from(o[z].yField):Ext.Array.from(o[z].xField)}if(C.fields.length){for(x=0,d=r.length;x<d;x++){if(t[r[x]]){break}}if(x==d){continue}}if(g=o[z].stacked){if(a.Bar&&o[z] instanceof a.Bar){if(o[z].column!=c){g=false;A=false}}else{if(!c){g=false;A=false}}}if(g){h={};for(x=0;x<r.length;x++){if(A&&o[z].__excludes&&o[z].__excludes[x]){continue}if(!t[r[x]]){Ext.Logger.warn("Field `"+r[x]+"` is not included in the "+D+" axis config.")}t[r[x]]=h[r[x]]=true}v.push({fields:h,value:0})}else{if(!r||r.length==0){r=C.fields}for(x=0;x<r.length;x++){if(A&&o[z].__excludes&&o[z].__excludes[x]){continue}t[r[x]]=B[r[x]]=true}}}for(z=0;z<m;z++){e=E[z];for(w=0;w<v.length;w++){v[w].value=0}for(b in t){s=e.get(b);if(isNaN(s)){continue}if(s===undefined){s=0}if(B[b]){if(u>s){u=s}if(y<s){y=s}}for(w=0;w<v.length;w++){if(v[w].fields[b]){v[w].value+=s;if(u>0){u=0}if(y<v[w].value){y=v[w].value}}}}}if(!isFinite(y)){y=C.prevMax||0}if(!isFinite(u)){u=C.prevMin||0}if(u!=y&&(y!=Math.floor(y))){y=Math.floor(y)+1}if(!isNaN(C.minimum)){u=C.minimum}if(!isNaN(C.maximum)){y=C.maximum}if(u>=y){y=u+1}return{min:u,max:y}},calcEnds:function(){var h=this,d=h.getRange(),g=d.min,a=d.max,c,i,e,b;c=(Ext.isNumber(h.majorTickSteps)?h.majorTickSteps+1:h.steps);i=!(Ext.isNumber(h.maximum)&&Ext.isNumber(h.minimum)&&Ext.isNumber(h.majorTickSteps)&&h.majorTickSteps>0);e=Ext.draw.Draw.snapEnds(g,a,c,i);if(Ext.isNumber(h.maximum)){e.to=h.maximum;b=true}if(Ext.isNumber(h.minimum)){e.from=h.minimum;b=true}if(h.adjustMaximumByMajorUnit){e.to=Math.ceil(e.to/e.step)*e.step;b=true}if(h.adjustMinimumByMajorUnit){e.from=Math.floor(e.from/e.step)*e.step;b=true}if(b){e.steps=Math.ceil((e.to-e.from)/e.step)}h.prevMin=(g==a?0:g);h.prevMax=a;return e},drawAxis:function(r){var C=this,s,j=C.x,h=C.y,A=C.chart.maxGutter[0],z=C.chart.maxGutter[1],e=C.dashSize,w=C.minorTickSteps||0,v=C.minorTickSteps||0,b=C.length,D=C.position,g=[],m=false,c=C.applyData(),d=c.step,t=c.steps,q=c.from,a=c.to,u,p,o,n,l,k,B;if(C.hidden||isNaN(d)||(q>a)){return}C.from=c.from;C.to=c.to;if(D=="left"||D=="right"){p=Math.floor(j)+0.5;n=["M",p,h,"l",0,-b];u=b-(z*2)}else{o=Math.floor(h)+0.5;n=["M",j,o,"l",b,0];u=b-(A*2)}B=t&&u/t;l=Math.max(w+1,0);k=Math.max(v+1,0);if(C.type=="Numeric"||C.type=="Time"){m=true;C.labels=[c.from]}if(D=="right"||D=="left"){o=h-z;p=j-((D=="left")*e*2);while(o>=h-z-u){n.push("M",p,Math.floor(o)+0.5,"l",e*2+1,0);if(o!=h-z){for(s=1;s<k;s++){n.push("M",p+e,Math.floor(o+B*s/k)+0.5,"l",e+1,0)}}g.push([Math.floor(j),Math.floor(o)]);o-=B;if(m){C.labels.push(C.labels[C.labels.length-1]+d)}if(B===0){break}}if(Math.round(o+B-(h-z-u))){n.push("M",p,Math.floor(h-b+z)+0.5,"l",e*2+1,0);for(s=1;s<k;s++){n.push("M",p+e,Math.floor(h-b+z+B*s/k)+0.5,"l",e+1,0)}g.push([Math.floor(j),Math.floor(o)]);if(m){C.labels.push(C.labels[C.labels.length-1]+d)}}}else{p=j+A;o=h-((D=="top")*e*2);while(p<=j+A+u){n.push("M",Math.floor(p)+0.5,o,"l",0,e*2+1);if(p!=j+A){for(s=1;s<l;s++){n.push("M",Math.floor(p-B*s/l)+0.5,o,"l",0,e+1)}}g.push([Math.floor(p),Math.floor(h)]);p+=B;if(m){C.labels.push(C.labels[C.labels.length-1]+d)}if(B===0){break}}if(Math.round(p-B-(j+A+u))){n.push("M",Math.floor(j+b-A)+0.5,o,"l",0,e*2+1);for(s=1;s<l;s++){n.push("M",Math.floor(j+b-A-B*s/l)+0.5,o,"l",0,e+1)}g.push([Math.floor(p),Math.floor(h)]);if(m){C.labels.push(C.labels[C.labels.length-1]+d)}}}if(m){C.labels[g.length-1]=+(C.labels[g.length-1]).toFixed(10)}if(!C.axis){C.axis=C.chart.surface.add(Ext.apply({type:"path",path:n},C.axisStyle))}C.axis.setAttributes({path:n},true);C.inflections=g;if(!r&&C.grid){C.drawGrid()}C.axisBBox=C.axis.getBBox();C.drawLabel()},drawGrid:function(){var t=this,o=t.chart.surface,b=t.grid,d=b.odd,e=b.even,h=t.inflections,j=h.length-((d||e)?0:1),u=t.position,c=t.chart.maxGutter,n=t.width-2,p,q,r=1,m=[],g,a,k,l=[],s=[];if((c[1]!==0&&(u=="left"||u=="right"))||(c[0]!==0&&(u=="top"||u=="bottom"))){r=0;j++}for(;r<j;r++){p=h[r];q=h[r-1];if(d||e){m=(r%2)?l:s;g=((r%2)?d:e)||{};a=(g.lineWidth||g["stroke-width"]||0)/2;k=2*a;if(u=="left"){m.push("M",q[0]+1+a,q[1]+0.5-a,"L",q[0]+1+n-a,q[1]+0.5-a,"L",p[0]+1+n-a,p[1]+0.5+a,"L",p[0]+1+a,p[1]+0.5+a,"Z")}else{if(u=="right"){m.push("M",q[0]-a,q[1]+0.5-a,"L",q[0]-n+a,q[1]+0.5-a,"L",p[0]-n+a,p[1]+0.5+a,"L",p[0]-a,p[1]+0.5+a,"Z")}else{if(u=="top"){m.push("M",q[0]+0.5+a,q[1]+1+a,"L",q[0]+0.5+a,q[1]+1+n-a,"L",p[0]+0.5-a,p[1]+1+n-a,"L",p[0]+0.5-a,p[1]+1+a,"Z")}else{m.push("M",q[0]+0.5+a,q[1]-a,"L",q[0]+0.5+a,q[1]-n+a,"L",p[0]+0.5-a,p[1]-n+a,"L",p[0]+0.5-a,p[1]-a,"Z")}}}}else{if(u=="left"){m=m.concat(["M",p[0]+0.5,p[1]+0.5,"l",n,0])}else{if(u=="right"){m=m.concat(["M",p[0]-0.5,p[1]+0.5,"l",-n,0])}else{if(u=="top"){m=m.concat(["M",p[0]+0.5,p[1]+0.5,"l",0,n])}else{m=m.concat(["M",p[0]+0.5,p[1]-0.5,"l",0,-n])}}}}}if(d||e){if(l.length){if(!t.gridOdd&&l.length){t.gridOdd=o.add({type:"path",path:l})}t.gridOdd.setAttributes(Ext.apply({path:l,hidden:false},d||{}),true)}if(s.length){if(!t.gridEven){t.gridEven=o.add({type:"path",path:s})}t.gridEven.setAttributes(Ext.apply({path:s,hidden:false},e||{}),true)}}else{if(m.length){if(!t.gridLines){t.gridLines=t.chart.surface.add({type:"path",path:m,"stroke-width":t.lineWidth||1,stroke:t.gridColor||"#ccc"})}t.gridLines.setAttributes({hidden:false,path:m},true)}else{if(t.gridLines){t.gridLines.hide(true)}}}},getOrCreateLabel:function(c,g){var d=this,b=d.labelGroup,e=b.getAt(c),a=d.chart.surface;if(e){if(g!=e.attr.text){e.setAttributes(Ext.apply({text:g},d.label),true);e._bbox=e.getBBox()}}else{e=a.add(Ext.apply({group:b,type:"text",x:0,y:0,text:g},d.label));a.renderItem(e);e._bbox=e.getBBox()}if(d.label.rotation){e.setAttributes({rotation:{degrees:0}},true);e._ubbox=e.getBBox();e.setAttributes(d.label,true)}else{e._ubbox=e._bbox}return e},rect2pointArray:function(l){var b=this.chart.surface,g=b.getBBox(l,true),m=[g.x,g.y],d=m.slice(),k=[g.x+g.width,g.y],a=k.slice(),j=[g.x+g.width,g.y+g.height],e=j.slice(),i=[g.x,g.y+g.height],c=i.slice(),h=l.matrix;m[0]=h.x.apply(h,d);m[1]=h.y.apply(h,d);k[0]=h.x.apply(h,a);k[1]=h.y.apply(h,a);j[0]=h.x.apply(h,e);j[1]=h.y.apply(h,e);i[0]=h.x.apply(h,c);i[1]=h.y.apply(h,c);return[m,k,j,i]},intersect:function(c,a){var d=this.rect2pointArray(c),b=this.rect2pointArray(a);return !!Ext.draw.Draw.intersect(d,b).length},drawHorizontalLabels:function(){var C=this,e=C.label,w=Math.floor,u=Math.max,v=C.chart.axes,g=C.chart.insetPadding,D=C.position,j=C.inflections,n=j.length,A=C.labels,r=0,h,c,s,o,b,B=C.adjustEnd,a=v.findIndex("position","left")!=-1,m=v.findIndex("position","right")!=-1,z,q,l,p,k,t,d;l=n-1;s=j[0];d=C.getOrCreateLabel(0,C.label.renderer(A[0]));h=Math.floor(Math.abs(Math.sin(e.rotate&&(e.rotate.degrees*Math.PI/180)||0)));for(t=0;t<n;t++){s=j[t];q=C.label.renderer(A[t]);z=C.getOrCreateLabel(t,q);c=z._bbox;r=u(r,c.height+C.dashSize+C.label.padding);p=w(s[0]-(h?c.height:c.width)/2);if(B&&C.chart.maxGutter[0]==0){if(t==0&&!a){p=s[0]}else{if(t==l&&!m){p=Math.min(p,s[0]-c.width+g)}}}if(D=="top"){k=s[1]-(C.dashSize*2)-C.label.padding-(c.height/2)}else{k=s[1]+(C.dashSize*2)+C.label.padding+(c.height/2)}z.setAttributes({hidden:false,x:p,y:k},true);if(t!=0&&(C.intersect(z,o)||C.intersect(z,d))){if(t===l&&b!==0){o.hide(true)}else{z.hide(true);continue}}o=z;b=t}return r},drawVerticalLabels:function(){var C=this,e=C.inflections,D=C.position,j=e.length,o=C.chart,d=o.insetPadding,B=C.labels,u=0,r=Math.max,t=Math.floor,c=Math.ceil,s=C.chart.axes,w=C.chart.maxGutter[1],b,p,k,a,n=s.findIndex("position","top")!=-1,v=s.findIndex("position","bottom")!=-1,A=C.adjustEnd,z,m,h=j-1,l,g,q;for(q=0;q<j;q++){p=e[q];m=C.label.renderer(B[q]);z=C.getOrCreateLabel(q,m);b=z._bbox;u=r(u,b.width+C.dashSize+C.label.padding);g=p[1];if(A&&w<b.height/2){if(q==h&&!n){g=Math.max(g,C.y-C.length+c(b.height/2)-d)}else{if(q==0&&!v){g=C.y+w-t(b.height/2)}}}if(D=="left"){l=p[0]-b.width-C.dashSize-C.label.padding-2}else{l=p[0]+C.dashSize+C.label.padding+2}z.setAttributes(Ext.apply({hidden:false,x:l,y:g},C.label),true);if(q!=0&&C.intersect(z,k)){if(q===h&&a!==0){k.hide(true)}else{z.hide(true);continue}}k=z;a=q}return u},drawLabel:function(){var h=this,a=h.position,b=h.labelGroup,j=h.inflections,g=0,e=0,d,c;if(a=="left"||a=="right"){g=h.drawVerticalLabels()}else{e=h.drawHorizontalLabels()}d=b.getCount();c=j.length;for(;c<d;c++){b.getAt(c).hide(true)}h.bbox={};Ext.apply(h.bbox,h.axisBBox);h.bbox.height=e;h.bbox.width=g;if(Ext.isString(h.title)){h.drawTitle(g,e)}},setTitle:function(a){this.title=a;this.drawLabel()},drawTitle:function(l,m){var h=this,g=h.position,b=h.chart.surface,c=h.displaySprite,k=h.title,e=(g=="left"||g=="right"),j=h.x,i=h.y,a,n,d;if(c){c.setAttributes({text:k},true)}else{a={type:"text",x:0,y:0,text:k};c=h.displaySprite=b.add(Ext.apply(a,h.axisTitleStyle,h.labelTitle));b.renderItem(c)}n=c.getBBox();d=h.dashSize+h.label.padding;if(e){i-=((h.length/2)-(n.height/2));if(g=="left"){j-=(l+d+(n.width/2))}else{j+=(l+d+n.width-(n.width/2))}h.bbox.width+=n.width+10}else{j+=(h.length/2)-(n.width*0.5);if(g=="top"){i-=(m+d+(n.height*0.3))}else{i+=(m+d+(n.height*0.8))}h.bbox.height+=n.height+10}c.setAttributes({translate:{x:j,y:i}},true)}});Ext.define("Ext.chart.axis.Category",{extend:"Ext.chart.axis.Axis",alternateClassName:"Ext.chart.CategoryAxis",alias:"axis.category",categoryNames:null,calculateCategoryCount:false,setLabels:function(){var c=this.chart.getChartStore(),j=c.data.items,k,g,b,a=this.fields,h=a.length,e;this.labels=[];for(k=0,g=j.length;k<g;k++){b=j[k];for(e=0;e<h;e++){this.labels.push(b.get(a[e]))}}},applyData:function(){this.callParent();this.setLabels();var a=this.chart.getChartStore().getCount();return{from:0,to:a-1,power:1,step:1,steps:a-1}}});Ext.define("Ext.chart.axis.Gauge",{extend:"Ext.chart.axis.Abstract",position:"gauge",alias:"axis.gauge",drawAxis:function(q){var j=this.chart,a=j.surface,p=j.chartBBox,d=p.x+(p.width/2),b=p.y+p.height,c=this.margin||10,m=Math.min(p.width,2*p.height)/2+c,h=[],n,l=this.steps,e,g=Math.PI,o=Math.cos,k=Math.sin;if(this.sprites&&!j.resizing){this.drawLabel();return}if(this.margin>=0){if(!this.sprites){for(e=0;e<=l;e++){n=a.add({type:"path",path:["M",d+(m-c)*o(e/l*g-g),b+(m-c)*k(e/l*g-g),"L",d+m*o(e/l*g-g),b+m*k(e/l*g-g),"Z"],stroke:"#ccc"});n.setAttributes({hidden:false},true);h.push(n)}}else{h=this.sprites;for(e=0;e<=l;e++){h[e].setAttributes({path:["M",d+(m-c)*o(e/l*g-g),b+(m-c)*k(e/l*g-g),"L",d+m*o(e/l*g-g),b+m*k(e/l*g-g),"Z"],stroke:"#ccc"},true)}}}this.sprites=h;this.drawLabel();if(this.title){this.drawTitle()}},drawTitle:function(){var e=this,d=e.chart,a=d.surface,g=d.chartBBox,c=e.titleSprite,b;if(!c){e.titleSprite=c=a.add({type:"text",zIndex:2})}c.setAttributes(Ext.apply({text:e.title},e.label||{}),true);b=c.getBBox();c.setAttributes({x:g.x+(g.width/2)-(b.width/2),y:g.y+g.height-(b.height/2)-4},true)},setTitle:function(a){this.title=a;this.drawTitle()},drawLabel:function(){var l=this.chart,p=l.surface,b=l.chartBBox,j=b.x+(b.width/2),h=b.y+b.height,m=this.margin||10,d=Math.min(b.width,2*b.height)/2+2*m,u=Math.round,n=[],g,s=this.maximum||0,k=this.minimum||0,r=this.steps,q=0,v,t=Math.PI,c=Math.cos,a=Math.sin,e=this.label,o=e.renderer||function(i){return i};if(!this.labelArray){for(q=0;q<=r;q++){v=(q===0||q===r)?7:0;g=p.add({type:"text",text:o(u(k+q/r*(s-k))),x:j+d*c(q/r*t-t),y:h+d*a(q/r*t-t)-v,"text-anchor":"middle","stroke-width":0.2,zIndex:10,stroke:"#333"});g.setAttributes({hidden:false},true);n.push(g)}}else{n=this.labelArray;for(q=0;q<=r;q++){v=(q===0||q===r)?7:0;n[q].setAttributes({text:o(u(k+q/r*(s-k))),x:j+d*c(q/r*t-t),y:h+d*a(q/r*t-t)-v},true)}}this.labelArray=n}});Ext.define("Ext.chart.axis.Numeric",{extend:"Ext.chart.axis.Axis",alternateClassName:"Ext.chart.NumericAxis",type:"numeric",alias:"axis.numeric",uses:["Ext.data.Store"],constructor:function(c){var d=this,a=!!(c.label&&c.label.renderer),b;d.callParent([c]);b=d.label;if(c.constrain==null){d.constrain=(c.minimum!=null&&c.maximum!=null)}if(!a){b.renderer=function(e){return d.roundToDecimal(e,d.decimals)}}},roundToDecimal:function(a,c){var b=Math.pow(10,c||0);return Math.round(a*b)/b},minimum:NaN,maximum:NaN,constrain:true,decimals:2,scale:"linear",doConstrain:function(){var t=this,b=t.chart.store,h=b.data.items,s,u,a,e=t.chart.series.items,j=t.fields,c=j.length,g=t.calcEnds(),m=g.from,p=g.to,q,n,r=false,k,v=[],o;for(q=0,n=e.length;q<n;q++){if(e[q].type==="bar"&&e[q].stacked){return}}for(s=0,u=h.length;s<u;s++){o=true;a=h[s];for(q=0;q<c;q++){k=a.get(j[q]);if(+k<+m){o=false;break}if(+k>+p){o=false;break}}if(o){v.push(a)}}t.chart.substore=Ext.create("Ext.data.Store",{model:b.model});t.chart.substore.loadData(v)},position:"left",adjustMaximumByMajorUnit:false,adjustMinimumByMajorUnit:false,processView:function(){var a=this,b=a.constrain;if(b){a.doConstrain()}},applyData:function(){this.callParent();return this.calcEnds()}});Ext.define("Ext.chart.axis.Radial",{extend:"Ext.chart.axis.Abstract",position:"radial",alias:"axis.radial",drawAxis:function(u){var m=this.chart,a=m.surface,t=m.chartBBox,q=m.store,b=q.getCount(),e=t.x+(t.width/2),c=t.y+(t.height/2),p=Math.min(t.width,t.height)/2,k=[],r,o=this.steps,g,d,h=Math.PI*2,s=Math.cos,n=Math.sin;if(this.sprites&&!m.resizing){this.drawLabel();return}if(!this.sprites){for(g=1;g<=o;g++){r=a.add({type:"circle",x:e,y:c,radius:Math.max(p*g/o,0),stroke:"#ccc"});r.setAttributes({hidden:false},true);k.push(r)}for(g=0;g<b;g++){r=a.add({type:"path",path:["M",e,c,"L",e+p*s(g/b*h),c+p*n(g/b*h),"Z"],stroke:"#ccc"});r.setAttributes({hidden:false},true);k.push(r)}}else{k=this.sprites;for(g=0;g<o;g++){k[g].setAttributes({x:e,y:c,radius:Math.max(p*(g+1)/o,0),stroke:"#ccc"},true)}for(d=0;d<b;d++){k[g+d].setAttributes({path:["M",e,c,"L",e+p*s(d/b*h),c+p*n(d/b*h),"Z"],stroke:"#ccc"},true)}}this.sprites=k;this.drawLabel()},drawLabel:function(){var w=this.chart,c=w.series.items,r,B=w.surface,b=w.chartBBox,l=w.store,J=l.data.items,p,k,o=b.x+(b.width/2),n=b.y+(b.height/2),h=Math.min(b.width,b.height)/2,F=Math.max,I=Math.round,x=[],m,z=[],d,A=[],g,v=!this.maximum,H=this.maximum||0,G=this.steps,E=0,D,t,s,y=Math.PI*2,e=Math.cos,a=Math.sin,C=this.label.display,q=C!=="none",u=10;if(!q){return}for(E=0,p=c.length;E<p;E++){r=c[E];z.push(r.yField);g=r.xField}for(D=0,p=J.length;D<p;D++){k=J[D];if(v){for(E=0,d=z.length;E<d;E++){H=F(+k.get(z[E]),H)}}A.push(k.get(g))}if(!this.labelArray){if(C!="categories"){for(E=1;E<=G;E++){m=B.add({type:"text",text:I(E/G*H),x:o,y:n-h*E/G,"text-anchor":"middle","stroke-width":0.1,stroke:"#333"});m.setAttributes({hidden:false},true);x.push(m)}}if(C!="scale"){for(D=0,G=A.length;D<G;D++){t=e(D/G*y)*(h+u);s=a(D/G*y)*(h+u);m=B.add({type:"text",text:A[D],x:o+t,y:n+s,"text-anchor":t*t<=0.001?"middle":(t<0?"end":"start")});m.setAttributes({hidden:false},true);x.push(m)}}}else{x=this.labelArray;if(C!="categories"){for(E=0;E<G;E++){x[E].setAttributes({text:I((E+1)/G*H),x:o,y:n-h*(E+1)/G,"text-anchor":"middle","stroke-width":0.1,stroke:"#333"},true)}}if(C!="scale"){for(D=0,G=A.length;D<G;D++){t=e(D/G*y)*(h+u);s=a(D/G*y)*(h+u);if(x[E+D]){x[E+D].setAttributes({type:"text",text:A[D],x:o+t,y:n+s,"text-anchor":t*t<=0.001?"middle":(t<0?"end":"start")},true)}}}}this.labelArray=x}});Ext.define("Ext.chart.axis.Time",{extend:"Ext.chart.axis.Numeric",alternateClassName:"Ext.chart.TimeAxis",alias:"axis.time",uses:["Ext.data.Store"],dateFormat:false,fromDate:false,toDate:false,step:[Ext.Date.DAY,1],constrain:false,constructor:function(b){var c=this,a,d,e;c.callParent([b]);a=c.label||{};e=this.dateFormat;if(e){if(a.renderer){d=a.renderer;a.renderer=function(g){g=d(g);return Ext.Date.format(new Date(d(g)),e)}}else{a.renderer=function(g){return Ext.Date.format(new Date(g>>0),e)}}}},processView:function(){var a=this;if(a.fromDate){a.minimum=+a.fromDate}if(a.toDate){a.maximum=+a.toDate}if(a.constrain){a.doConstrain()}},calcEnds:function(){var c=this,a,b=c.step;if(b){a=c.getRange();a=Ext.draw.Draw.snapEndsByDateAndStep(new Date(a.min),new Date(a.max),Ext.isNumber(b)?[Date.MILLI,b]:b);if(c.minimum){a.from=c.minimum}if(c.maximum){a.to=c.maximum}a.step=(a.to-a.from)/a.steps;return a}else{return c.callParent(arguments)}}});Ext.define("Ext.chart.series.Series",{mixins:{observable:"Ext.util.Observable",labels:"Ext.chart.Label",highlights:"Ext.chart.Highlight",tips:"Ext.chart.Tip",callouts:"Ext.chart.Callout"},type:null,title:null,showInLegend:true,renderer:function(e,a,c,d,b){return c},shadowAttributes:null,animating:false,constructor:function(a){var b=this;if(a){Ext.apply(b,a)}b.shadowGroups=[];b.mixins.labels.constructor.call(b,a);b.mixins.highlights.constructor.call(b,a);b.mixins.tips.constructor.call(b,a);b.mixins.callouts.constructor.call(b,a);b.addEvents({scope:b,itemmouseover:true,itemmouseout:true,itemmousedown:true,itemmouseup:true,mouseleave:true,afterdraw:true,titlechange:true});b.mixins.observable.constructor.call(b,a);b.on({scope:b,itemmouseover:b.onItemMouseOver,itemmouseout:b.onItemMouseOut,mouseleave:b.onMouseLeave});if(b.style){Ext.apply(b.seriesStyle,b.style)}},eachRecord:function(c,b){var a=this.chart;(a.substore||a.store).each(c,b)},getRecordCount:function(){var b=this.chart,a=b.substore||b.store;return a?a.getCount():0},isExcluded:function(a){var b=this.__excludes;return !!(b&&b[a])},setBBox:function(a){var e=this,c=e.chart,b=c.chartBBox,g=a?0:c.maxGutter[0],d=a?0:c.maxGutter[1],h,i;h={x:b.x,y:b.y,width:b.width,height:b.height};e.clipBox=h;i={x:(h.x+g)-(c.zoom.x*c.zoom.width),y:(h.y+d)-(c.zoom.y*c.zoom.height),width:(h.width-(g*2))*c.zoom.width,height:(h.height-(d*2))*c.zoom.height};e.bbox=i},onAnimate:function(b,a){var c=this;b.stopAnimation();if(c.animating){return b.animate(Ext.applyIf(a,c.chart.animate))}else{c.animating=true;return b.animate(Ext.apply(Ext.applyIf(a,c.chart.animate),{listeners:{afteranimate:function(){c.animating=false;c.fireEvent("afterrender")}}}))}},getGutters:function(){return[0,0]},onItemMouseOver:function(b){var a=this;if(b.series===a){if(a.highlight){a.highlightItem(b)}if(a.tooltip){a.showTip(b)}}},onItemMouseOut:function(b){var a=this;if(b.series===a){a.unHighlightItem();if(a.tooltip){a.hideTip(b)}}},onMouseLeave:function(){var a=this;a.unHighlightItem();if(a.tooltip){a.hideTip()}},getItemForPoint:function(a,j){if(!this.items||!this.items.length||this.seriesIsHidden){return null}var g=this,b=g.items,h=g.bbox,e,c,d;if(!Ext.draw.Draw.withinBox(a,j,h)){return null}for(c=0,d=b.length;c<d;c++){if(b[c]&&this.isItemInPoint(a,j,b[c],c)){return b[c]}}return null},isItemInPoint:function(a,d,c,b){return false},hideAll:function(){var h=this,g=h.items,m,e,d,c,a,k,b;h.seriesIsHidden=true;h._prevShowMarkers=h.showMarkers;h.showMarkers=false;h.hideLabels(0);for(d=0,e=g.length;d<e;d++){m=g[d];k=m.sprite;if(k){k.setAttributes({hidden:true},true)}if(k&&k.shadows){b=k.shadows;for(c=0,a=b.length;c<a;++c){b[c].setAttributes({hidden:true},true)}}}},showAll:function(){var a=this,b=a.chart.animate;a.chart.animate=false;a.seriesIsHidden=false;a.showMarkers=a._prevShowMarkers;a.drawSeries();a.chart.animate=b},hide:function(){if(this.items){var h=this,b=h.items,d,c,a,g,e;if(b&&b.length){for(d=0,g=b.length;d<g;++d){if(b[d].sprite){b[d].sprite.hide(true);e=b[d].shadows||b[d].sprite.shadows;if(e){for(c=0,a=e.length;c<a;++c){e[c].hide(true)}}}}h.hideLabels()}}},getLegendColor:function(a){var b=this,d,c;if(b.seriesStyle){d=b.seriesStyle.fill;c=b.seriesStyle.stroke;if(d&&d!="none"){return d}if(c){return c}}return(b.colorArrayStyle)?b.colorArrayStyle[b.seriesIdx%b.colorArrayStyle.length]:"#000"},visibleInLegend:function(a){var b=this.__excludes;if(b){return !b[a]}return !this.seriesIsHidden},setTitle:function(a,d){var c=this,b=c.title;if(Ext.isString(a)){d=a;a=0}if(Ext.isArray(b)){b[a]=d}else{c.title=d}c.fireEvent("titlechange",d,a)}});Ext.define("Ext.chart.series.Cartesian",{extend:"Ext.chart.series.Series",alternateClassName:["Ext.chart.CartesianSeries","Ext.chart.CartesianChart"],xField:null,yField:null,axis:"left",getLegendLabels:function(){var j=this,e=[],g,d,h,k=j.combinations,l,a,c,b;g=[].concat(j.yField);for(d=0,h=g.length;d<h;d++){l=j.title;e.push((Ext.isArray(l)?l[d]:l)||g[d])}if(k){k=Ext.Array.from(k);for(d=0,h=k.length;d<h;d++){a=k[d];c=e[a[0]];b=e[a[1]];e[a[1]]=c+" & "+b;e.splice(a[0],1)}}return e},eachYValue:function(b,e,d){var j=this,h=j.getYValueAccessors(),c,g,a;for(c=0,g=h.length;c<g;c++){a=h[c];e.call(d,a(b),c)}},getYValueCount:function(){return this.getYValueAccessors().length},combine:function(g,e){var d=this,c=d.getYValueAccessors(),b=c[g],a=c[e];c[e]=function(h){return b(h)+a(h)};c.splice(g,1);d.callParent([g,e])},clearCombinations:function(){delete this.yValueAccessors;this.callParent()},getYValueAccessors:function(){var e=this,a=e.yValueAccessors,g,c,b,d;if(!a){a=e.yValueAccessors=[];g=[].concat(e.yField);for(b=0,d=g.length;b<d;b++){c=g[b];a.push(function(h){return h.get(c)})}}return a},getMinMaxXValues:function(){var k=this,j=k.chart,m=j.getChartStore(),d=m.data.items,e,h,g,c,l,a=k.xField,b;if(k.getRecordCount()>0){c=Infinity;l=-c;for(e=0,h=d.length;e<h;e++){g=d[e];b=g.get(a);if(b>l){l=b}if(b<c){c=b}}}else{c=l=0}return[c,l]},getMinMaxYValues:function(){var k=this,j=k.chart,o=j.getChartStore(),c=o.data.items,d,h,e,g=k.stacked,b,l,n,m;function a(r,q){if(!k.isExcluded(q)){if(r<0){m+=r}else{n+=r}}}function p(r,q){if(!k.isExcluded(q)){if(r>l){l=r}if(r<b){b=r}}}if(k.getRecordCount()>0){b=Infinity;l=-b;for(d=0,h=c.length;d<h;d++){e=c[d];if(g){n=0;m=0;k.eachYValue(e,a);if(n>l){l=n}if(m<b){b=m}}else{k.eachYValue(e,p)}}}else{b=l=0}return[b,l]},getAxesForXAndYFields:function(){var m=this,l=m.chart.axes,d=[].concat(m.axis),c={},e=[].concat(m.yField),n={},o=[].concat(m.xField),j,b,a,h,k,g;g=m.type==="bar"&&m.column===false;if(g){j=e;e=o;o=j}if(Ext.Array.indexOf(d,"top")>-1){b="top"}else{if(Ext.Array.indexOf(d,"bottom")>-1){b="bottom"}else{if(l.get("top")&&l.get("bottom")){for(h=0,k=o.length;h<k;h++){n[o[h]]=true}j=[].concat(l.get("bottom").fields);for(h=0,k=j.length;h<k;h++){if(n[j[h]]){b="bottom";break}}j=[].concat(l.get("top").fields);for(h=0,k=j.length;h<k;h++){if(n[j[h]]){b="top";break}}}else{if(l.get("top")){b="top"}else{if(l.get("bottom")){b="bottom"}}}}}if(Ext.Array.indexOf(d,"left")>-1){a="left"}else{if(Ext.Array.indexOf(d,"right")>-1){a="right"}else{if(l.get("left")&&l.get("right")){for(h=0,k=e.length;h<k;h++){c[e[h]]=true}j=[].concat(l.get("right").fields);for(h=0,k=j.length;h<k;h++){if(c[j[h]]){break}}j=[].concat(l.get("left").fields);for(h=0,k=j.length;h<k;h++){if(c[j[h]]){a="left";break}}}else{if(l.get("left")){a="left"}else{if(l.get("right")){a="right"}}}}}return g?{xAxis:a,yAxis:b}:{xAxis:b,yAxis:a}}});Ext.define("Ext.chart.series.Area",{extend:"Ext.chart.series.Cartesian",alias:"series.area",requires:["Ext.chart.axis.Axis","Ext.draw.Color","Ext.fx.Anim"],type:"area",stacked:true,style:{},constructor:function(c){this.callParent(arguments);var e=this,a=e.chart.surface,d,b;c.highlightCfg=Ext.Object.merge({},{lineWidth:3,stroke:"#55c",opacity:0.8,color:"#f00"},c.highlightCfg);Ext.apply(e,c,{__excludes:[]});if(e.highlight){e.highlightSprite=a.add({type:"path",path:["M",0,0],zIndex:1000,opacity:0.3,lineWidth:5,hidden:true,stroke:"#444"})}e.group=a.getGroup(e.seriesId)},shrink:function(b,n,o){var k=b.length,m=Math.floor(k/o),h,g,d=0,l=this.areas.length,a=[],e=[],c=[];for(g=0;g<l;++g){a[g]=0}for(h=0;h<k;++h){d+=+b[h];for(g=0;g<l;++g){a[g]+=+n[h][g]}if(h%m==0){e.push(d/m);for(g=0;g<l;++g){a[g]/=m}c.push(a);d=0;for(g=0,a=[];g<l;++g){a[g]=0}}}return{x:e,y:c}},getBounds:function(){var j=this,M=j.chart,a=M.getChartStore(),L=a.data.items,I,F,x,v=[].concat(j.yField),A=v.length,z=[],D=[],g=Infinity,C=g,B=g,n=-g,m=-g,s=Math,w=s.min,e=s.max,p=j.getAxesForXAndYFields(),J=p.xAxis,u=p.yAxis,G,r,k,h,E,q,N,K,b,t,H,c,d,o,y;j.setBBox();k=j.bbox;if(o=M.axes.get(J)){if(o.type==="Time"){r=true}G=o.applyData();C=G.from;n=G.to}if(o=M.axes.get(u)){G=o.applyData();B=G.from;m=G.to}if(j.xField&&!Ext.isNumber(C)){o=j.getMinMaxXValues();r=true;C=o[0];n=o[1]}if(j.yField&&!Ext.isNumber(B)){o=j.getMinMaxYValues();B=o[0];m=o[1]}if(!Ext.isNumber(B)){B=0}if(!Ext.isNumber(m)){m=0}for(I=0,F=L.length;I<F;I++){x=L[I];q=x.get(j.xField);N=[];if(typeof q!="number"){if(r){q=+q}else{q=I}}z.push(q);b=0;for(K=0;K<A;K++){if(j.__excludes[K]){continue}d=x.get(v[K]);if(typeof d=="number"){N.push(d)}}D.push(N)}h=k.width/((n-C)||1);E=k.height/((m-B)||1);t=z.length;if((t>k.width)&&j.areas){H=j.shrink(z,D,k.width);z=H.x;D=H.y}return{bbox:k,minX:C,minY:B,xValues:z,yValues:D,xScale:h,yScale:E,areasLen:A}},getPaths:function(){var w=this,m=w.chart,c=m.getChartStore(),e=true,g=w.getBounds(),a=g.bbox,n=w.items=[],v=[],b,d=0,p=[],s,j,k,h,q,t,l,z,r,u,o;j=g.xValues.length;for(s=0;s<j;s++){q=g.xValues[s];t=g.yValues[s];k=a.x+(q-g.minX)*g.xScale;l=0;d=0;for(z=0;z<g.areasLen;z++){if(w.__excludes[z]){continue}if(!v[z]){v[z]=[]}u=t[d];l+=u;h=a.y+a.height-(l-g.minY)*g.yScale;if(!p[z]){p[z]=["M",k,h];v[z].push(["L",k,h])}else{p[z].push("L",k,h);v[z].push(["L",k,h])}if(!n[z]){n[z]={pointsUp:[],pointsDown:[],series:w}}n[z].pointsUp.push([k,h]);d++}}for(z=0;z<g.areasLen;z++){if(w.__excludes[z]){continue}o=p[z];if(z==0||e){e=false;o.push("L",k,a.y+a.height,"L",a.x,a.y+a.height,"Z")}else{b=v[r];b.reverse();o.push("L",k,b[0][2]);for(s=0;s<j;s++){o.push(b[s][0],b[s][1],b[s][2]);n[z].pointsDown[j-s-1]=[b[s][1],b[s][2]]}o.push("L",a.x,o[2],"Z")}r=z}return{paths:p,areasLen:g.areasLen}},drawSeries:function(){var h=this,g=h.chart,i=g.getChartStore(),c=g.surface,b=g.animate,k=h.group,a=Ext.apply(h.seriesStyle,h.style),l=h.colorArrayStyle,o=l&&l.length||0,d,e,n,m,j;h.unHighlightItem();h.cleanHighlights();if(!i||!i.getCount()||h.seriesIsHidden){h.hide();h.items=[];return}n=h.getPaths();if(!h.areas){h.areas=[]}for(d=0;d<n.areasLen;d++){if(h.__excludes[d]){continue}if(!h.areas[d]){h.items[d].sprite=h.areas[d]=c.add(Ext.apply({},{type:"path",group:k,path:n.paths[d],stroke:a.stroke||l[d%o],fill:l[d%o]},a||{}))}e=h.areas[d];m=n.paths[d];if(b){j=h.renderer(e,false,{path:m,fill:l[d%o],stroke:a.stroke||l[d%o]},d,i);h.animation=h.onAnimate(e,{to:j})}else{j=h.renderer(e,false,{path:m,hidden:false,fill:l[d%o],stroke:a.stroke||l[d%o]},d,i);h.areas[d].setAttributes(j,true)}}h.renderLabels();h.renderCallouts()},onAnimate:function(b,a){b.show();return this.callParent(arguments)},onCreateLabel:function(d,k,c,e){var g=this,h=g.labelsGroup,a=g.label,j=g.bbox,b=Ext.apply(a,g.seriesLabelStyle);return g.chart.surface.add(Ext.apply({type:"text","text-anchor":"middle",group:h,x:k.point[0],y:j.y+j.height/2},b||{}))},onPlaceLabel:function(g,k,s,p,o,c,e){var u=this,l=u.chart,r=l.resizing,t=u.label,q=t.renderer,b=t.field,a=u.bbox,j=s.point[0],h=s.point[1],d,n,m;g.setAttributes({text:q(k.get(b[e])),hidden:true},true);d=g.getBBox();n=d.width/2;m=d.height/2;j=j-n<a.x?a.x+n:j;j=(j+n>a.x+a.width)?(j-(j+n-a.x-a.width)):j;h=h-m<a.y?a.y+m:h;h=(h+m>a.y+a.height)?(h-(h+m-a.y-a.height)):h;if(u.chart.animate&&!u.chart.resizing){g.show(true);u.onAnimate(g,{to:{x:j,y:h}})}else{g.setAttributes({x:j,y:h},true);if(r){u.animation.on("afteranimate",function(){g.show(true)})}else{g.show(true)}}},onPlaceCallout:function(m,r,J,G,F,d,k){var M=this,s=M.chart,D=s.surface,H=s.resizing,L=M.callouts,t=M.items,v=(G==0)?false:t[G-1].point,z=(G==t.length-1)?false:t[G+1].point,c=J.point,A,g,N,K,o,q,b=m.label.getBBox(),I=30,C=10,B=3,h,e,j,w,u,E=M.clipRect,n,l;if(!v){v=c}if(!z){z=c}K=(z[1]-v[1])/(z[0]-v[0]);o=(c[1]-v[1])/(c[0]-v[0]);q=(z[1]-c[1])/(z[0]-c[0]);g=Math.sqrt(1+K*K);A=[1/g,K/g];N=[-A[1],A[0]];if(o>0&&q<0&&N[1]<0||o<0&&q>0&&N[1]>0){N[0]*=-1;N[1]*=-1}else{if(Math.abs(o)<Math.abs(q)&&N[0]<0||Math.abs(o)>Math.abs(q)&&N[0]>0){N[0]*=-1;N[1]*=-1}}n=c[0]+N[0]*I;l=c[1]+N[1]*I;h=n+(N[0]>0?0:-(b.width+2*B));e=l-b.height/2-B;j=b.width+2*B;w=b.height+2*B;if(h<E[0]||(h+j)>(E[0]+E[2])){N[0]*=-1}if(e<E[1]||(e+w)>(E[1]+E[3])){N[1]*=-1}n=c[0]+N[0]*I;l=c[1]+N[1]*I;h=n+(N[0]>0?0:-(b.width+2*B));e=l-b.height/2-B;j=b.width+2*B;w=b.height+2*B;m.lines.setAttributes({path:["M",c[0],c[1],"L",n,l,"Z"]},true);m.box.setAttributes({x:h,y:e,width:j,height:w},true);m.label.setAttributes({x:n+(N[0]>0?B:-(b.width+B)),y:l},true);for(u in m){m[u].show(true)}},isItemInPoint:function(j,h,m,c){var g=this,b=m.pointsUp,d=m.pointsDown,q=Math.abs,o=false,l=false,e=Infinity,a,n,k;for(a=0,n=b.length;a<n;a++){k=[b[a][0],b[a][1]];o=false;l=a==n-1;if(e>q(j-k[0])){e=q(j-k[0]);o=true;if(l){++a}}if(!o||(o&&l)){k=b[a-1];if(h>=k[1]&&(!d.length||h<=(d[a-1][1]))){m.storeIndex=a-1;m.storeField=g.yField[c];m.storeItem=g.chart.store.getAt(a-1);m._points=d.length?[k,d[a-1]]:[k];return true}else{break}}}return false},highlightSeries:function(){var a,c,b;if(this._index!==undefined){a=this.areas[this._index];if(a.__highlightAnim){a.__highlightAnim.paused=true}a.__highlighted=true;a.__prevOpacity=a.__prevOpacity||a.attr.opacity||1;a.__prevFill=a.__prevFill||a.attr.fill;a.__prevLineWidth=a.__prevLineWidth||a.attr.lineWidth;b=Ext.draw.Color.fromString(a.__prevFill);c={lineWidth:(a.__prevLineWidth||0)+2};if(b){c.fill=b.getLighter(0.2).toString()}else{c.opacity=Math.max(a.__prevOpacity-0.3,0)}if(this.chart.animate){a.__highlightAnim=new Ext.fx.Anim(Ext.apply({target:a,to:c},this.chart.animate))}else{a.setAttributes(c,true)}}},unHighlightSeries:function(){var a;if(this._index!==undefined){a=this.areas[this._index];if(a.__highlightAnim){a.__highlightAnim.paused=true}if(a.__highlighted){a.__highlighted=false;a.__highlightAnim=new Ext.fx.Anim({target:a,to:{fill:a.__prevFill,opacity:a.__prevOpacity,lineWidth:a.__prevLineWidth}})}}},highlightItem:function(c){var b=this,a,d;if(!c){this.highlightSeries();return}a=c._points;d=a.length==2?["M",a[0][0],a[0][1],"L",a[1][0],a[1][1]]:["M",a[0][0],a[0][1],"L",a[0][0],b.bbox.y+b.bbox.height];b.highlightSprite.setAttributes({path:d,hidden:false},true)},unHighlightItem:function(a){if(!a){this.unHighlightSeries()}if(this.highlightSprite){this.highlightSprite.hide(true)}},hideAll:function(a){var b=this;a=(isNaN(b._index)?a:b._index)||0;b.__excludes[a]=true;b.areas[a].hide(true);b.redraw()},showAll:function(a){var b=this;a=(isNaN(b._index)?a:b._index)||0;b.__excludes[a]=false;b.areas[a].show(true);b.redraw()},redraw:function(){var a=this,b;b=a.chart.legend.rebuild;a.chart.legend.rebuild=false;a.chart.redraw();a.chart.legend.rebuild=b},hide:function(){if(this.areas){var h=this,b=h.areas,d,c,a,g,e;if(b&&b.length){for(d=0,g=b.length;d<g;++d){if(b[d]){b[d].hide(true)}}h.hideLabels()}}},getLegendColor:function(a){var b=this;return b.colorArrayStyle[a%b.colorArrayStyle.length]}});Ext.define("Ext.chart.series.Bar",{extend:"Ext.chart.series.Cartesian",alternateClassName:["Ext.chart.BarSeries","Ext.chart.BarChart","Ext.chart.StackedBarChart"],requires:["Ext.chart.axis.Axis","Ext.fx.Anim"],type:"bar",alias:"series.bar",column:false,style:{},gutter:38.2,groupGutter:38.2,xPadding:0,yPadding:10,constructor:function(c){this.callParent(arguments);var e=this,a=e.chart.surface,g=e.chart.shadow,d,b;c.highlightCfg=Ext.Object.merge({lineWidth:3,stroke:"#55c",opacity:0.8,color:"#f00"},c.highlightCfg);Ext.apply(e,c,{shadowAttributes:[{"stroke-width":6,"stroke-opacity":0.05,stroke:"rgb(200, 200, 200)",translate:{x:1.2,y:1.2}},{"stroke-width":4,"stroke-opacity":0.1,stroke:"rgb(150, 150, 150)",translate:{x:0.9,y:0.9}},{"stroke-width":2,"stroke-opacity":0.15,stroke:"rgb(100, 100, 100)",translate:{x:0.6,y:0.6}}]});e.group=a.getGroup(e.seriesId+"-bars");if(g){for(d=0,b=e.shadowAttributes.length;d<b;d++){e.shadowGroups.push(a.getGroup(e.seriesId+"-shadows"+d))}}},getBarGirth:function(){var d=this,a=d.chart.getChartStore(),b=d.column,c=a.getCount(),e=d.gutter/100;return(d.chart.chartBBox[b?"width":"height"]-d[b?"xPadding":"yPadding"]*2)/(c*(e+1)-e)},getGutters:function(){var b=this,a=b.column,c=Math.ceil(b[a?"xPadding":"yPadding"]+b.getBarGirth()/2);return b.column?[c,0]:[0,c]},getBounds:function(){var o=this,O=o.chart,b=O.getChartStore(),N=b.data.items,M,x,D,v=[].concat(o.yField),p=v.length,l=p,c=o.groupGutter/100,H=o.column,h=o.xPadding,m=o.yPadding,J=o.stacked,t=o.getBarGirth(),y=H?"width":"height",u=Math,B=u.min,k=u.max,n=u.abs,G=o.getAxesForXAndYFields(),A=G.yAxis,L,C,e,q,F,r,s,E,z,a,w,I,K,d,g;o.setBBox(true);q=o.bbox;if(o.__excludes){for(K=0,w=o.__excludes.length;K<w;K++){if(o.__excludes[K]){l--}}}s=O.axes.get(A);if(s){L=s.applyData();F=L.from;r=L.to}if(o.yField&&!Ext.isNumber(F)){E=o.getMinMaxYValues();F=E[0];r=E[1]}if(!Ext.isNumber(F)){F=0}if(!Ext.isNumber(r)){r=0}z=(H?q.height-m*2:q.width-h*2)/(r-F);C=t;e=(t/((J?1:l)*(c+1)-c));if(y in o.style){e=B(e,o.style[y]);C=e*((J?1:l)*(c+1)-c)}a=(H)?q.y+q.height-m:q.x+h;if(J){w=[[],[]];for(M=0,x=N.length;M<x;M++){D=N[M];w[0][M]=w[0][M]||0;w[1][M]=w[1][M]||0;for(K=0;K<p;K++){if(o.__excludes&&o.__excludes[K]){continue}I=D.get(v[K]);w[+(I>0)][M]+=n(I)}}w[+(r>0)].push(n(r));w[+(F>0)].push(n(F));g=k.apply(u,w[0]);d=k.apply(u,w[1]);z=(H?q.height-m*2:q.width-h*2)/(d+g);a=a+g*z*(H?-1:1)}else{if(F/r<0){a=a-F*z*(H?-1:1)}}return{bars:v,bbox:q,shrunkBarWidth:C,barsLen:p,groupBarsLen:l,barWidth:t,groupBarWidth:e,scale:z,zero:a,xPadding:h,yPadding:m,signed:F/r<0,minY:F,maxY:r}},getPaths:function(){var v=this,X=v.chart,b=X.getChartStore(),W=b.data.items,V,E,L,G=v.bounds=v.getBounds(),z=v.items=[],P=v.yField,l=v.gutter/100,c=v.groupGutter/100,T=X.animate,N=v.column,x=v.group,m=X.shadow,R=v.shadowGroups,Q=v.shadowAttributes,q=R.length,y=G.bbox,B=G.barWidth,K=G.shrunkBarWidth,n=v.xPadding,r=v.yPadding,S=v.stacked,w=G.barsLen,O=v.colorArrayStyle,h=O&&O.length||0,C=Math,o=C.max,I=C.min,u=C.abs,U,Y,e,J,D,a,k,t,s,p,g,d,F,A,M,H;for(V=0,E=W.length;V<E;V++){L=W[V];a=G.zero;k=G.zero;J=0;D=0;t=false;for(U=0,g=0;U<w;U++){if(v.__excludes&&v.__excludes[U]){continue}Y=L.get(G.bars[U]);e=Math.round((Y-o(G.minY,0))*G.scale);s={fill:O[(w>1?U:0)%h]};if(N){Ext.apply(s,{height:e,width:o(G.groupBarWidth,0),x:(y.x+n+(B-K)*0.5+V*B*(1+l)+g*G.groupBarWidth*(1+c)*!S),y:a-e})}else{M=(E-1)-V;Ext.apply(s,{height:o(G.groupBarWidth,0),width:e+(a==G.zero),x:a+(a!=G.zero),y:(y.y+r+(B-K)*0.5+M*B*(1+l)+g*G.groupBarWidth*(1+c)*!S+1)})}if(e<0){if(N){s.y=k;s.height=u(e)}else{s.x=k+e;s.width=u(e)}}if(S){if(e<0){k+=e*(N?-1:1)}else{a+=e*(N?-1:1)}J+=u(e);if(e<0){D+=u(e)}}s.x=Math.floor(s.x)+1;H=Math.floor(s.y);if(!Ext.isIE9&&s.y>H){H--}s.y=H;s.width=Math.floor(s.width);s.height=Math.floor(s.height);z.push({series:v,yField:P[U],storeItem:L,value:[L.get(v.xField),Y],attr:s,point:N?[s.x+s.width/2,Y>=0?s.y:s.y+s.height]:[Y>=0?s.x+s.width:s.x,s.y+s.height/2]});if(T&&X.resizing){p=N?{x:s.x,y:G.zero,width:s.width,height:0}:{x:G.zero,y:s.y,width:0,height:s.height};if(m&&(S&&!t||!S)){t=true;for(d=0;d<q;d++){F=R[d].getAt(S?V:(V*w+U));if(F){F.setAttributes(p,true)}}}A=x.getAt(V*w+U);if(A){A.setAttributes(p,true)}}g++}if(S&&z.length){z[V*g].totalDim=J;z[V*g].totalNegDim=D}}if(S&&g==0){for(V=0,E=W.length;V<E;V++){for(d=0;d<q;d++){F=R[d].getAt(V);if(F){F.hide(true)}}}}},renderShadows:function(u,v,y,l){var z=this,p=z.chart,s=p.surface,g=p.animate,x=z.stacked,a=z.shadowGroups,w=z.shadowAttributes,o=a.length,h=p.getChartStore(),d=z.column,r=z.items,b=[],m=l.zero,e,q,k,A,n,t,c;if((x&&(u%l.groupBarsLen===0))||!x){t=u/l.groupBarsLen;for(e=0;e<o;e++){q=Ext.apply({},w[e]);k=a[e].getAt(x?t:u);Ext.copyTo(q,v,"x,y,width,height");if(!k){k=s.add(Ext.apply({type:"rect",group:a[e]},Ext.apply({},y,q)))}if(x){A=r[u].totalDim;n=r[u].totalNegDim;if(d){q.y=m+n-A-1;q.height=A}else{q.x=m-n;q.width=A}}c=z.renderer(k,h.getAt(t),q,u,h);c.hidden=!!v.hidden;if(g){z.onAnimate(k,{to:c})}else{k.setAttributes(c,true)}b.push(k)}}return b},drawSeries:function(){var C=this,r=C.chart,m=r.getChartStore(),v=r.surface,k=r.animate,A=C.stacked,d=C.column,b=r.shadow,a=C.shadowGroups,q=a.length,o=C.group,g=C.seriesStyle,s,p,y,x,B,t,c,e,h,n,l,z,u,w;if(!m||!m.getCount()||C.seriesIsHidden){C.hide();C.items=[];return}l=Ext.apply({},this.style,g);delete l.fill;delete l.x;delete l.y;delete l.width;delete l.height;C.unHighlightItem();C.cleanHighlights();C.getPaths();n=C.bounds;s=C.items;B=d?{y:n.zero,height:0}:{x:n.zero,width:0};p=s.length;for(y=0;y<p;y++){t=o.getAt(y);z=s[y].attr;if(b){s[y].shadows=C.renderShadows(y,z,B,n)}if(!t){u=Ext.apply({},B,z);u=Ext.apply(u,l||{});t=v.add(Ext.apply({},{type:"rect",group:o},u))}if(k){c=C.renderer(t,m.getAt(y),z,y,m);t._to=c;w=C.onAnimate(t,{to:Ext.apply(c,l)});if(b&&A&&(y%n.barsLen===0)){x=y/n.barsLen;for(e=0;e<q;e++){w.on("afteranimate",function(){this.show(true)},a[e].getAt(x))}}}else{c=C.renderer(t,m.getAt(y),Ext.apply(z,{hidden:false}),y,m);t.setAttributes(Ext.apply(c,l),true)}s[y].sprite=t}p=o.getCount();for(x=y;x<p;x++){o.getAt(x).hide(true)}if(C.stacked){y=m.getCount()}if(b){for(e=0;e<q;e++){h=a[e];p=h.getCount();for(x=y;x<p;x++){h.getAt(x).hide(true)}}}C.renderLabels()},onCreateLabel:function(e,l,d,g){var h=this,a=h.chart.surface,k=h.labelsGroup,b=h.label,c=Ext.apply({},b,h.seriesLabelStyle||{}),j;return a.add(Ext.apply({type:"text",group:k},c||{}))},onPlaceLabel:function(G,N,s,J,p,H,I,v){var m=this,n=m.bounds,d=n.groupBarWidth,F=m.column,L=m.chart,u=L.chartBBox,A=L.resizing,o=s.value[0],O=s.value[1],l=s.attr,z=m.label,K=z.orientation=="vertical",h=[].concat(z.field),t=z.renderer,r=t(N.get(h[v])),g=m.getLabelSize(r),a=g.width,c=g.height,b=n.zero,k="outside",q="insideStart",M="insideEnd",E=10,C=6,e=n.signed,D,B,w;G.setAttributes({text:r});G.isOutside=false;if(F){if(p==k){if(c+C+l.height>(O>=0?b-u.y:u.y+u.height-b)){p=M}}else{if(c+C>l.height){p=k;G.isOutside=true}}D=l.x+d/2;B=p==q?(b+((c/2+3)*(O>=0?-1:1))):(O>=0?(l.y+((c/2+3)*(p==k?-1:1))):(l.y+l.height+((c/2+3)*(p===k?1:-1))))}else{if(p==k){if(a+E+l.width>(O>=0?u.x+u.width-b:b-u.x)){p=M}}else{if(a+E>l.width){p=k;G.isOutside=true}}D=p==q?(b+((a/2+5)*(O>=0?1:-1))):(O>=0?(l.x+l.width+((a/2+5)*(p===k?1:-1))):(l.x+((a/2+5)*(p===k?-1:1))));B=l.y+d/2}w={x:D,y:B};if(K){w.rotate={x:D,y:B,degrees:270}}if(H&&A){if(F){D=l.x+l.width/2;B=b}else{D=b;B=l.y+l.height/2}G.setAttributes({x:D,y:B},true);if(K){G.setAttributes({rotate:{x:D,y:B,degrees:270}},true)}}if(H){m.onAnimate(G,{to:w})}else{G.setAttributes(Ext.apply(w,{hidden:false}),true)}},getLabelSize:function(g){var k=this.testerLabel,a=this.label,d=Ext.apply({},a,this.seriesLabelStyle||{}),b=a.orientation==="vertical",j,i,e,c;if(!k){k=this.testerLabel=this.chart.surface.add(Ext.apply({type:"text",opacity:0},d))}k.setAttributes({text:g},true);j=k.getBBox();i=j.width;e=j.height;return{width:b?e:i,height:b?i:e}},onAnimate:function(b,a){b.show();return this.callParent(arguments)},isItemInPoint:function(a,d,b){var c=b.sprite.getBBox();return c.x<=a&&c.y<=d&&(c.x+c.width)>=a&&(c.y+c.height)>=d},hideAll:function(a){var e=this.chart.axes,c=e.items,d=c.length,b=0;a=(isNaN(this._index)?a:this._index)||0;if(!this.__excludes){this.__excludes=[]}this.__excludes[a]=true;this.drawSeries();for(b;b<d;b++){c[b].drawAxis()}},showAll:function(a){var e=this.chart.axes,c=e.items,d=c.length,b=0;a=(isNaN(this._index)?a:this._index)||0;if(!this.__excludes){this.__excludes=[]}this.__excludes[a]=false;this.drawSeries();for(b;b<d;b++){c[b].drawAxis()}},getLegendColor:function(a){var c=this,b=c.colorArrayStyle.length;if(c.style&&c.style.fill){return c.style.fill}else{return c.colorArrayStyle[a%b]}},highlightItem:function(a){this.callParent(arguments);this.renderLabels()},unHighlightItem:function(){this.callParent(arguments);this.renderLabels()},cleanHighlights:function(){this.callParent(arguments);this.renderLabels()}});Ext.define("Ext.chart.series.Column",{alternateClassName:["Ext.chart.ColumnSeries","Ext.chart.ColumnChart","Ext.chart.StackedColumnChart"],extend:"Ext.chart.series.Bar",type:"column",alias:"series.column",column:true,xPadding:10,yPadding:0});Ext.define("Ext.chart.series.Gauge",{extend:"Ext.chart.series.Series",type:"gauge",alias:"series.gauge",rad:Math.PI/180,highlightDuration:150,angleField:false,needle:false,donut:false,showInLegend:false,style:{},constructor:function(b){this.callParent(arguments);var h=this,g=h.chart,a=g.surface,j=g.store,k=g.shadow,d,c,e;Ext.apply(h,b,{shadowAttributes:[{"stroke-width":6,"stroke-opacity":1,stroke:"rgb(200, 200, 200)",translate:{x:1.2,y:2}},{"stroke-width":4,"stroke-opacity":1,stroke:"rgb(150, 150, 150)",translate:{x:0.9,y:1.5}},{"stroke-width":2,"stroke-opacity":1,stroke:"rgb(100, 100, 100)",translate:{x:0.6,y:1}}]});h.group=a.getGroup(h.seriesId);if(k){for(d=0,c=h.shadowAttributes.length;d<c;d++){h.shadowGroups.push(a.getGroup(h.seriesId+"-shadows"+d))}}a.customAttributes.segment=function(i){return h.getSegment(i)}},initialize:function(){var d=this,a=d.chart.getChartStore(),e=a.data.items,b,c,g;d.yField=[];if(d.label.field){for(b=0,c=e.length;b<c;b++){g=e[b];d.yField.push(g.get(d.label.field))}}},getSegment:function(b){var C=this,B=C.rad,d=Math.cos,a=Math.sin,n=Math.abs,k=C.centerX,i=C.centerY,w=0,v=0,u=0,s=0,h=0,g=0,e=0,c=0,z=0.01,m=b.endRho-b.startRho,q=b.startAngle,p=b.endAngle,j=(q+p)/2*B,l=b.margin||0,t=n(p-q)>180,D=Math.min(q,p)*B,A=Math.max(q,p)*B,o=false;k+=l*d(j);i+=l*a(j);w=k+b.startRho*d(D);h=i+b.startRho*a(D);v=k+b.endRho*d(D);g=i+b.endRho*a(D);u=k+b.startRho*d(A);e=i+b.startRho*a(A);s=k+b.endRho*d(A);c=i+b.endRho*a(A);if(n(w-u)<=z&&n(h-e)<=z){o=true}if(o){return{path:[["M",w,h],["L",v,g],["A",b.endRho,b.endRho,0,+t,1,s,c],["Z"]]}}else{return{path:[["M",w,h],["L",v,g],["A",b.endRho,b.endRho,0,+t,1,s,c],["L",u,e],["A",b.startRho,b.startRho,0,+t,0,w,h],["Z"]]}}},calcMiddle:function(p){var k=this,l=k.rad,o=p.slice,n=k.centerX,m=k.centerY,j=o.startAngle,e=o.endAngle,i=Math.max(("rho" in o)?o.rho:k.radius,k.label.minMargin),h=+k.donut,b=Math.min(j,e)*l,a=Math.max(j,e)*l,d=-(b+(a-b)/2),g=n+(p.endRho+p.startRho)/2*Math.cos(d),c=m-(p.endRho+p.startRho)/2*Math.sin(d);p.middle={x:g,y:c}},drawSeries:function(){var w=this,W=w.chart,b=W.getChartStore(),A=w.group,S=w.chart.animate,D=w.chart.axes.get(0),E=D&&D.minimum||w.minimum||0,I=D&&D.maximum||w.maximum||0,n=w.angleField||w.field||w.xField,M=W.surface,H=W.chartBBox,h=w.rad,c=+w.donut,X={},B=[],m=w.seriesStyle,a=w.seriesLabelStyle,g=w.colorArrayStyle,z=g&&g.length||0,K=W.maxGutter[0],J=W.maxGutter[1],k=Math.cos,s=Math.sin,t,e,d,v,r,C,O,F,G,L,U,T,l,V,x,o,Q,R,q,y,u,P,N;Ext.apply(m,w.style||{});w.setBBox();y=w.bbox;if(w.colorSet){g=w.colorSet;z=g.length}if(!b||!b.getCount()||w.seriesIsHidden){w.hide();w.items=[];return}e=w.centerX=H.x+(H.width/2);d=w.centerY=H.y+H.height;w.radius=Math.min(e-H.x,d-H.y);w.slices=r=[];w.items=B=[];if(!w.value){L=b.getAt(0);w.value=L.get(n)}O=w.value;if(w.needle){P={series:w,value:O,startAngle:-180,endAngle:0,rho:w.radius};u=-180*(1-(O-E)/(I-E));r.push(P)}else{u=-180*(1-(O-E)/(I-E));P={series:w,value:O,startAngle:-180,endAngle:u,rho:w.radius};N={series:w,value:w.maximum-O,startAngle:u,endAngle:0,rho:w.radius};r.push(P,N)}for(U=0,G=r.length;U<G;U++){v=r[U];C=A.getAt(U);t=Ext.apply({segment:{startAngle:v.startAngle,endAngle:v.endAngle,margin:0,rho:v.rho,startRho:v.rho*+c/100,endRho:v.rho}},Ext.apply(m,g&&{fill:g[U%z]}||{}));F=Ext.apply({},t.segment,{slice:v,series:w,storeItem:L,index:U});B[U]=F;if(!C){q=Ext.apply({type:"path",group:A},Ext.apply(m,g&&{fill:g[U%z]}||{}));C=M.add(Ext.apply(q,t))}v.sprite=v.sprite||[];F.sprite=C;v.sprite.push(C);if(S){t=w.renderer(C,L,t,U,b);C._to=t;w.onAnimate(C,{to:t})}else{t=w.renderer(C,L,Ext.apply(t,{hidden:false}),U,b);C.setAttributes(t,true)}}if(w.needle){u=u*Math.PI/180;if(!w.needleSprite){w.needleSprite=w.chart.surface.add({type:"path",path:["M",e+(w.radius*+c/100)*k(u),d+-Math.abs((w.radius*+c/100)*s(u)),"L",e+w.radius*k(u),d+-Math.abs(w.radius*s(u))],"stroke-width":4,stroke:"#222"})}else{if(S){w.onAnimate(w.needleSprite,{to:{path:["M",e+(w.radius*+c/100)*k(u),d+-Math.abs((w.radius*+c/100)*s(u)),"L",e+w.radius*k(u),d+-Math.abs(w.radius*s(u))]}})}else{w.needleSprite.setAttributes({type:"path",path:["M",e+(w.radius*+c/100)*k(u),d+-Math.abs((w.radius*+c/100)*s(u)),"L",e+w.radius*k(u),d+-Math.abs(w.radius*s(u))]})}}w.needleSprite.setAttributes({hidden:false},true)}delete w.value},setValue:function(a){this.value=a;this.drawSeries()},onCreateLabel:function(c,b,a,d){},onPlaceLabel:function(c,g,e,d,h,a,b){},onPlaceCallout:function(){},onAnimate:function(b,a){b.show();return this.callParent(arguments)},isItemInPoint:function(l,j,n,e){var h=this,d=h.centerX,c=h.centerY,p=Math.abs,o=p(l-d),m=p(j-c),g=n.startAngle,a=n.endAngle,k=Math.sqrt(o*o+m*m),b=Math.atan2(j-c,l-d)/h.rad;return(e===0)&&(b>=g&&b<a&&k>=n.startRho&&k<=n.endRho)},showAll:function(){if(!isNaN(this._index)){this.__excludes[this._index]=false;this.drawSeries()}},getLegendColor:function(a){var b=this;return b.colorArrayStyle[a%b.colorArrayStyle.length]}});Ext.define("Ext.chart.series.Line",{extend:"Ext.chart.series.Cartesian",alternateClassName:["Ext.chart.LineSeries","Ext.chart.LineChart"],requires:["Ext.chart.axis.Axis","Ext.chart.Shape","Ext.draw.Draw","Ext.fx.Anim"],type:"line",alias:"series.line",selectionTolerance:20,showMarkers:true,markerConfig:{},style:{},smooth:false,defaultSmoothness:3,fill:false,constructor:function(c){this.callParent(arguments);var e=this,a=e.chart.surface,g=e.chart.shadow,d,b;c.highlightCfg=Ext.Object.merge({"stroke-width":3},c.highlightCfg);Ext.apply(e,c,{shadowAttributes:[{"stroke-width":6,"stroke-opacity":0.05,stroke:"rgb(0, 0, 0)",translate:{x:1,y:1}},{"stroke-width":4,"stroke-opacity":0.1,stroke:"rgb(0, 0, 0)",translate:{x:1,y:1}},{"stroke-width":2,"stroke-opacity":0.15,stroke:"rgb(0, 0, 0)",translate:{x:1,y:1}}]});e.group=a.getGroup(e.seriesId);if(e.showMarkers){e.markerGroup=a.getGroup(e.seriesId+"-markers")}if(g){for(d=0,b=e.shadowAttributes.length;d<b;d++){e.shadowGroups.push(a.getGroup(e.seriesId+"-shadows"+d))}}},shrink:function(b,k,l){var h=b.length,j=Math.floor(h/l),g=1,d=0,a=0,e=[+b[0]],c=[+k[0]];for(;g<h;++g){d+=+b[g]||0;a+=+k[g]||0;if(g%j==0){e.push(d/j);c.push(a/j);d=0;a=0}}return{x:e,y:c}},drawSeries:function(){var an=this,aA=an.chart,V=aA.axes,av=aA.getChartStore(),A=av.data.items,ar,Y=av.getCount(),w=an.chart.surface,au={},U=an.group,N=an.showMarkers,aG=an.markerGroup,G=aA.shadow,F=an.shadowGroups,ab=an.shadowAttributes,R=an.smooth,r=F.length,ay=["M"],W=["M"],d=["M"],b=["M"],M=aA.markerIndex,am=[].concat(an.axis),al,aB=[],ak={},ae=[],z={},L=false,T=[],aF=an.markerStyle,ad=an.seriesStyle,v=an.colorArrayStyle,S=v&&v.length||0,O=Ext.isNumber,aC=an.seriesIdx,h=an.getAxesForXAndYFields(),m=h.xAxis,aE=h.yAxis,ag,k,af,ah,D,c,ai,K,J,g,e,u,s,aa,Q,P,az,n,I,H,aH,o,q,E,a,ac,aj,C,ax,B,aw,p,aD,at,aq,X,l,t,ao,ap,Z;if(an.fireEvent("beforedraw",an)===false){return}if(!Y||an.seriesIsHidden){an.hide();an.items=[];if(an.line){an.line.hide(true);if(an.line.shadows){ag=an.line.shadows;for(P=0,r=ag.length;P<r;P++){k=ag[P];k.hide(true)}}if(an.fillPath){an.fillPath.hide(true)}}an.line=null;an.fillPath=null;return}at=Ext.apply(aF||{},an.markerConfig,{fill:an.seriesStyle.fill||v[aC%v.length]});X=at.type;delete at.type;aq=ad;if(!aq["stroke-width"]){aq["stroke-width"]=0.5}t="opacity" in aq?aq.opacity:1;Z="opacity" in aq?aq.opacity:0.3;ao="lineOpacity" in aq?aq.lineOpacity:t;ap="fillOpacity" in aq?aq.fillOpacity:Z;if(M&&aG&&aG.getCount()){for(Q=0;Q<M;Q++){H=aG.getAt(Q);aG.remove(H);aG.add(H);aH=aG.getAt(aG.getCount()-2);H.setAttributes({x:0,y:0,translate:{x:aH.attr.translation.x,y:aH.attr.translation.y}},true)}}an.unHighlightItem();an.cleanHighlights();an.setBBox();au=an.bbox;an.clipRect=[au.x,au.y,au.width,au.height];if(n=V.get(m)){I=n.applyData();C=I.from;ax=I.to}if(n=V.get(aE)){I=n.applyData();B=I.from;aw=I.to}if(an.xField&&!Ext.isNumber(C)){n=an.getMinMaxXValues();C=n[0];ax=n[1]}if(an.yField&&!Ext.isNumber(B)){n=an.getMinMaxYValues();B=n[0];aw=n[1]}if(isNaN(C)){C=0;ac=au.width/((Y-1)||1)}else{ac=au.width/((ax-C)||(Y-1)||1)}if(isNaN(B)){B=0;aj=au.height/((Y-1)||1)}else{aj=au.height/((aw-B)||(Y-1)||1)}for(Q=0,az=A.length;Q<az;Q++){ar=A[Q];q=ar.get(an.xField);if(typeof q=="string"||typeof q=="object"&&!Ext.isDate(q)||m&&V.get(m)&&V.get(m).type=="Category"){if(q in ak){q=ak[q]}else{q=ak[q]=Q}}E=ar.get(an.yField);if(typeof E=="undefined"||(typeof E=="string"&&!E)){continue}if(typeof E=="string"||typeof E=="object"&&!Ext.isDate(E)||aE&&V.get(aE)&&V.get(aE).type=="Category"){E=Q}T.push(Q);aB.push(q);ae.push(E)}az=aB.length;if(az>au.width){a=an.shrink(aB,ae,au.width);aB=a.x;ae=a.y}an.items=[];l=0;az=aB.length;for(Q=0;Q<az;Q++){q=aB[Q];E=ae[Q];if(E===false){if(W.length==1){W=[]}L=true;an.items.push(false);continue}else{K=(au.x+(q-C)*ac).toFixed(2);J=((au.y+au.height)-(E-B)*aj).toFixed(2);if(L){L=false;W.push("M")}W=W.concat([K,J])}if((typeof s=="undefined")&&(typeof J!="undefined")){s=J;u=K}if(!an.line||aA.resizing){ay=ay.concat([K,au.y+au.height/2])}if(aA.animate&&aA.resizing&&an.line){an.line.setAttributes({path:ay,opacity:ao},true);if(an.fillPath){an.fillPath.setAttributes({path:ay,opacity:ap},true)}if(an.line.shadows){ag=an.line.shadows;for(P=0,r=ag.length;P<r;P++){k=ag[P];k.setAttributes({path:ay},true)}}}if(N){H=aG.getAt(l++);if(!H){H=Ext.chart.Shape[X](w,Ext.apply({group:[U,aG],x:0,y:0,translate:{x:+(g||K),y:e||(au.y+au.height/2)},value:'"'+q+", "+E+'"',zIndex:4000},at));H._to={translate:{x:+K,y:+J}}}else{H.setAttributes({value:'"'+q+", "+E+'"',x:0,y:0,hidden:false},true);H._to={translate:{x:+K,y:+J}}}}an.items.push({series:an,value:[q,E],point:[K,J],sprite:H,storeItem:av.getAt(T[Q])});g=K;e=J}if(W.length<=1){return}if(an.smooth){b=Ext.draw.Draw.smooth(W,O(R)?R:an.defaultSmoothness)}d=R?b:W;if(aA.markerIndex&&an.previousPath){ah=an.previousPath;if(!R){Ext.Array.erase(ah,1,2)}}else{ah=W}if(!an.line){an.line=w.add(Ext.apply({type:"path",group:U,path:ay,stroke:aq.stroke||aq.fill},aq||{}));an.line.setAttributes({opacity:ao},true);if(G){an.line.setAttributes(Ext.apply({},an.shadowOptions),true)}an.line.setAttributes({fill:"none",zIndex:3000});if(!aq.stroke&&S){an.line.setAttributes({stroke:v[aC%S]},true)}if(G){ag=an.line.shadows=[];for(af=0;af<r;af++){al=ab[af];al=Ext.apply({},al,{path:ay});k=w.add(Ext.apply({},{type:"path",group:F[af]},al));ag.push(k)}}}if(an.fill){c=d.concat([["L",K,au.y+au.height],["L",u,au.y+au.height],["L",u,s]]);if(!an.fillPath){an.fillPath=w.add({group:U,type:"path",fill:aq.fill||v[aC%S],path:ay})}}aa=N&&aG.getCount();if(aA.animate){D=an.fill;p=an.line;ai=an.renderer(p,false,{path:d},Q,av);Ext.apply(ai,aq||{},{stroke:aq.stroke||aq.fill});delete ai.fill;p.show(true);if(aA.markerIndex&&an.previousPath){an.animation=aD=an.onAnimate(p,{to:ai,from:{path:ah}})}else{an.animation=aD=an.onAnimate(p,{to:ai})}if(G){ag=p.shadows;for(P=0;P<r;P++){ag[P].show(true);if(aA.markerIndex&&an.previousPath){an.onAnimate(ag[P],{to:{path:d},from:{path:ah}})}else{an.onAnimate(ag[P],{to:{path:d}})}}}if(D){an.fillPath.show(true);an.onAnimate(an.fillPath,{to:Ext.apply({},{path:c,fill:aq.fill||v[aC%S],"stroke-width":0,opacity:ap},aq||{})})}if(N){l=0;for(Q=0;Q<az;Q++){if(an.items[Q]){o=aG.getAt(l++);if(o){ai=an.renderer(o,av.getAt(Q),o._to,Q,av);an.onAnimate(o,{to:Ext.apply(ai,at||{})});o.show(true)}}}for(;l<aa;l++){o=aG.getAt(l);o.hide(true)}}}else{ai=an.renderer(an.line,false,{path:d,hidden:false},Q,av);Ext.apply(ai,aq||{},{stroke:aq.stroke||aq.fill});delete ai.fill;an.line.setAttributes(ai,true);an.line.setAttributes({opacity:ao},true);if(G){ag=an.line.shadows;for(P=0;P<r;P++){ag[P].setAttributes({path:d,hidden:false},true)}}if(an.fill){an.fillPath.setAttributes({path:c,hidden:false,opacity:ap},true)}if(N){l=0;for(Q=0;Q<az;Q++){if(an.items[Q]){o=aG.getAt(l++);if(o){ai=an.renderer(o,av.getAt(Q),o._to,Q,av);o.setAttributes(Ext.apply(at||{},ai||{}),true);if(!o.attr.hidden){o.show(true)}}}}for(;l<aa;l++){o=aG.getAt(l);o.hide(true)}}}if(aA.markerIndex){if(an.smooth){Ext.Array.erase(W,1,2)}else{Ext.Array.splice(W,1,0,W[1],W[2])}an.previousPath=W}an.renderLabels();an.renderCallouts();an.fireEvent("draw",an)},onCreateLabel:function(d,k,c,e){var g=this,h=g.labelsGroup,a=g.label,j=g.bbox,b=Ext.apply(a,g.seriesLabelStyle);return g.chart.surface.add(Ext.apply({type:"text","text-anchor":"middle",group:h,x:k.point[0],y:j.y+j.height/2},b||{}))},onPlaceLabel:function(g,k,s,p,o,d){var u=this,l=u.chart,r=l.resizing,t=u.label,q=t.renderer,b=t.field,a=u.bbox,j=s.point[0],h=s.point[1],c=s.sprite.attr.radius,e,n,m;g.setAttributes({text:q(k.get(b)),hidden:true},true);if(o=="rotate"){g.setAttributes({"text-anchor":"start",rotation:{x:j,y:h,degrees:-45}},true);e=g.getBBox();n=e.width;m=e.height;j=j<a.x?a.x:j;j=(j+n>a.x+a.width)?(j-(j+n-a.x-a.width)):j;h=(h-m<a.y)?a.y+m:h}else{if(o=="under"||o=="over"){e=s.sprite.getBBox();e.width=e.width||(c*2);e.height=e.height||(c*2);h=h+(o=="over"?-e.height:e.height);e=g.getBBox();n=e.width/2;m=e.height/2;j=j-n<a.x?a.x+n:j;j=(j+n>a.x+a.width)?(j-(j+n-a.x-a.width)):j;h=h-m<a.y?a.y+m:h;h=(h+m>a.y+a.height)?(h-(h+m-a.y-a.height)):h}}if(u.chart.animate&&!u.chart.resizing){g.show(true);u.onAnimate(g,{to:{x:j,y:h}})}else{g.setAttributes({x:j,y:h},true);if(r&&u.animation){u.animation.on("afteranimate",function(){g.show(true)})}else{g.show(true)}}},highlightItem:function(){var a=this;a.callParent(arguments);if(a.line&&!a.highlighted){if(!("__strokeWidth" in a.line)){a.line.__strokeWidth=parseFloat(a.line.attr["stroke-width"])||0}if(a.line.__anim){a.line.__anim.paused=true}a.line.__anim=Ext.create("Ext.fx.Anim",{target:a.line,to:{"stroke-width":a.line.__strokeWidth+3}});a.highlighted=true}},unHighlightItem:function(){var a=this;a.callParent(arguments);if(a.line&&a.highlighted){a.line.__anim=Ext.create("Ext.fx.Anim",{target:a.line,to:{"stroke-width":a.line.__strokeWidth}});a.highlighted=false}},onPlaceCallout:function(m,r,J,G,F,d,k){if(!F){return}var M=this,s=M.chart,D=s.surface,H=s.resizing,L=M.callouts,t=M.items,v=G==0?false:t[G-1].point,z=(G==t.length-1)?false:t[G+1].point,c=[+J.point[0],+J.point[1]],A,g,N,K,o,q,I=L.offsetFromViz||30,C=L.offsetToSide||10,B=L.offsetBox||3,h,e,j,w,u,E=M.clipRect,b={width:L.styles.width||10,height:L.styles.height||10},n,l;if(!v){v=c}if(!z){z=c}K=(z[1]-v[1])/(z[0]-v[0]);o=(c[1]-v[1])/(c[0]-v[0]);q=(z[1]-c[1])/(z[0]-c[0]);g=Math.sqrt(1+K*K);A=[1/g,K/g];N=[-A[1],A[0]];if(o>0&&q<0&&N[1]<0||o<0&&q>0&&N[1]>0){N[0]*=-1;N[1]*=-1}else{if(Math.abs(o)<Math.abs(q)&&N[0]<0||Math.abs(o)>Math.abs(q)&&N[0]>0){N[0]*=-1;N[1]*=-1}}n=c[0]+N[0]*I;l=c[1]+N[1]*I;h=n+(N[0]>0?0:-(b.width+2*B));e=l-b.height/2-B;j=b.width+2*B;w=b.height+2*B;if(h<E[0]||(h+j)>(E[0]+E[2])){N[0]*=-1}if(e<E[1]||(e+w)>(E[1]+E[3])){N[1]*=-1}n=c[0]+N[0]*I;l=c[1]+N[1]*I;h=n+(N[0]>0?0:-(b.width+2*B));e=l-b.height/2-B;j=b.width+2*B;w=b.height+2*B;if(s.animate){M.onAnimate(m.lines,{to:{path:["M",c[0],c[1],"L",n,l,"Z"]}});if(m.panel){m.panel.setPosition(h,e,true)}}else{m.lines.setAttributes({path:["M",c[0],c[1],"L",n,l,"Z"]},true);if(m.panel){m.panel.setPosition(h,e)}}for(u in m){m[u].show(true)}},isItemInPoint:function(j,g,A,q){var C=this,n=C.items,s=C.selectionTolerance,k=null,z,c,p,v,h,w,b,t,a,l,B,e,d,o,u,r,D=Math.sqrt,m=Math.abs;c=n[q];z=q&&n[q-1];if(q>=h){z=n[h-1]}p=z&&z.point;v=c&&c.point;w=z?p[0]:v[0]-s;b=z?p[1]:v[1];t=c?v[0]:p[0]+s;a=c?v[1]:p[1];e=D((j-w)*(j-w)+(g-b)*(g-b));d=D((j-t)*(j-t)+(g-a)*(g-a));o=Math.min(e,d);if(o<=s){return o==e?z:c}return false},toggleAll:function(a){var e=this,b,d,g,c;if(!a){Ext.chart.series.Cartesian.prototype.hideAll.call(e)}else{Ext.chart.series.Cartesian.prototype.showAll.call(e)}if(e.line){e.line.setAttributes({hidden:!a},true);if(e.line.shadows){for(b=0,c=e.line.shadows,d=c.length;b<d;b++){g=c[b];g.setAttributes({hidden:!a},true)}}}if(e.fillPath){e.fillPath.setAttributes({hidden:!a},true)}},hideAll:function(){this.toggleAll(false)},showAll:function(){this.toggleAll(true)}});Ext.define("Ext.chart.series.Pie",{alternateClassName:["Ext.chart.PieSeries","Ext.chart.PieChart"],extend:"Ext.chart.series.Series",type:"pie",alias:"series.pie",accuracy:100000,rad:Math.PI*2/100000,highlightDuration:150,angleField:false,lengthField:false,donut:false,showInLegend:false,style:{},constructor:function(b){this.callParent(arguments);var h=this,g=h.chart,a=g.surface,j=g.store,k=g.shadow,d,c,e;b.highlightCfg=Ext.merge({segment:{margin:20}},b.highlightCfg);Ext.apply(h,b,{shadowAttributes:[{"stroke-width":6,"stroke-opacity":1,stroke:"rgb(200, 200, 200)",translate:{x:1.2,y:2}},{"stroke-width":4,"stroke-opacity":1,stroke:"rgb(150, 150, 150)",translate:{x:0.9,y:1.5}},{"stroke-width":2,"stroke-opacity":1,stroke:"rgb(100, 100, 100)",translate:{x:0.6,y:1}}]});h.group=a.getGroup(h.seriesId);if(k){for(d=0,c=h.shadowAttributes.length;d<c;d++){h.shadowGroups.push(a.getGroup(h.seriesId+"-shadows"+d))}}a.customAttributes.segment=function(l){var i=h.getSegment(l);if(!i.path||i.path.length===0){i.path=["M",0,0]}return i};h.__excludes=h.__excludes||[]},initialize:function(){var d=this,a=d.chart.getChartStore(),e=a.data.items,b,c,g;d.yField=[];if(d.label.field){for(b=0,c=e.length;b<c;b++){g=e[b];d.yField.push(g.get(d.label.field))}}},getSegment:function(d){var J=this,I=J.rad,i=Math.cos,a=Math.sin,p=J.centerX,n=J.centerY,E=0,D=0,C=0,A=0,l=0,k=0,j=0,g=0,w=0,c=0,v=0,b=0,G=0.01,z=d.startAngle,u=d.endAngle,o=(z+u)/2*I,r=d.margin||0,K=Math.min(z,u)*I,H=Math.max(z,u)*I,t=i(K),h=a(K),s=i(H),e=a(H),m=i(o),F=a(o),B=0,q=0.7071067811865476;if(H-K<G){return{path:""}}if(r!==0){p+=r*m;n+=r*F}D=p+d.endRho*t;k=n+d.endRho*h;A=p+d.endRho*s;g=n+d.endRho*e;v=p+d.endRho*m;b=n+d.endRho*F;if(d.startRho!==0){E=p+d.startRho*t;l=n+d.startRho*h;C=p+d.startRho*s;j=n+d.startRho*e;w=p+d.startRho*m;c=n+d.startRho*F;return{path:[["M",D,k],["A",d.endRho,d.endRho,0,0,1,v,b],["L",v,b],["A",d.endRho,d.endRho,0,B,1,A,g],["L",A,g],["L",C,j],["A",d.startRho,d.startRho,0,B,0,w,c],["L",w,c],["A",d.startRho,d.startRho,0,0,0,E,l],["L",E,l],["Z"]]}}else{return{path:[["M",p,n],["L",D,k],["A",d.endRho,d.endRho,0,0,1,v,b],["L",v,b],["A",d.endRho,d.endRho,0,B,1,A,g],["L",A,g],["L",p,n],["Z"]]}}},calcMiddle:function(n){var i=this,j=i.rad,m=n.slice,l=i.centerX,k=i.centerY,h=m.startAngle,d=m.endAngle,g=+i.donut,c=-(h+d)*j/2,a=(n.endRho+n.startRho)/2,e=l+a*Math.cos(c),b=k-a*Math.sin(c);n.middle={x:e,y:b}},drawSeries:function(){var s=this,a=s.chart.getChartStore(),W=a.data.items,I,x=s.group,S=s.chart.animate,k=s.angleField||s.field||s.xField,A=[].concat(s.lengthField),R=0,X=s.chart,J=X.surface,G=X.chartBBox,g=X.shadow,Q=s.shadowGroups,P=s.shadowAttributes,aa=Q.length,K=A.length,B=0,b=+s.donut,Z=[],y=[],u=0,M=0,t=0,h=s.seriesStyle,e=s.colorArrayStyle,w=e&&e.length||0,o,Y,C,H,E,d,c,q,l=0,r,n,z,L,D,ab,F,U,T,V,N,O,m,v;Ext.apply(h,s.style||{});s.setBBox();v=s.bbox;if(s.colorSet){e=s.colorSet;w=e.length}if(!a||!a.getCount()||s.seriesIsHidden){s.hide();s.items=[];return}s.unHighlightItem();s.cleanHighlights();d=s.centerX=G.x+(G.width/2);c=s.centerY=G.y+(G.height/2);s.radius=Math.min(d-G.x,c-G.y);s.slices=n=[];s.items=y=[];for(U=0,F=W.length;U<F;U++){I=W[U];if(this.__excludes&&this.__excludes[U]){continue}u+=+I.get(k);if(A[0]){for(T=0,R=0;T<K;T++){R+=+I.get(A[T])}Z[U]=R;M=Math.max(M,R)}}u=u||1;for(U=0,F=W.length;U<F;U++){I=W[U];if(this.__excludes&&this.__excludes[U]){L=0}else{L=I.get(k);if(l==0){l=1}}if(l==1){l=2;s.firstAngle=t=s.accuracy*L/u/2;for(T=0;T<U;T++){n[T].startAngle=n[T].endAngle=s.firstAngle}}V=t-s.accuracy*L/u;r={series:s,value:L,startAngle:t,endAngle:V,storeItem:I};if(A[0]){ab=+Z[U];r.rho=Math.floor(s.radius/M*ab)}else{r.rho=s.radius}n[U]=r;(function(){t=V})()}if(g){for(U=0,F=n.length;U<F;U++){r=n[U];r.shadowAttrs=[];for(T=0,B=0,C=[];T<K;T++){z=x.getAt(U*K+T);q=A[T]?a.getAt(U).get(A[T])/Z[U]*r.rho:r.rho;o={segment:{startAngle:r.startAngle,endAngle:r.endAngle,margin:0,rho:r.rho,startRho:B+(q*b/100),endRho:B+q},hidden:!r.value&&(r.startAngle%s.accuracy)==(r.endAngle%s.accuracy)};for(E=0,C=[];E<aa;E++){Y=P[E];H=Q[E].getAt(U);if(!H){H=X.surface.add(Ext.apply({},{type:"path",group:Q[E],strokeLinejoin:"round"},o,Y))}Y=s.renderer(H,a.getAt(U),Ext.apply({},o,Y),U,a);if(S){s.onAnimate(H,{to:Y})}else{H.setAttributes(Y,true)}C.push(H)}r.shadowAttrs[T]=C}}}for(U=0,F=n.length;U<F;U++){r=n[U];for(T=0,B=0;T<K;T++){z=x.getAt(U*K+T);q=A[T]?a.getAt(U).get(A[T])/Z[U]*r.rho:r.rho;o=Ext.apply({segment:{startAngle:r.startAngle,endAngle:r.endAngle,margin:0,rho:r.rho,startRho:B+(q*b/100),endRho:B+q},hidden:(!r.value&&(r.startAngle%s.accuracy)==(r.endAngle%s.accuracy))},Ext.apply(h,e&&{fill:e[(K>1?T:U)%w]}||{}));D=Ext.apply({},o.segment,{slice:r,series:s,storeItem:r.storeItem,index:U});s.calcMiddle(D);if(g){D.shadows=r.shadowAttrs[T]}y[U]=D;if(!z){m=Ext.apply({type:"path",group:x,middle:D.middle},Ext.apply(h,e&&{fill:e[(K>1?T:U)%w]}||{}));z=J.add(Ext.apply(m,o))}r.sprite=r.sprite||[];D.sprite=z;r.sprite.push(z);r.point=[D.middle.x,D.middle.y];if(S){o=s.renderer(z,a.getAt(U),o,U,a);z._to=o;z._animating=true;s.onAnimate(z,{to:o,listeners:{afteranimate:{fn:function(){this._animating=false},scope:z}}})}else{o=s.renderer(z,a.getAt(U),Ext.apply(o,{hidden:false}),U,a);z.setAttributes(o,true)}B+=q}}F=x.getCount();for(U=0;U<F;U++){if(!n[(U/K)>>0]&&x.getAt(U)){x.getAt(U).hide(true)}}if(g){aa=Q.length;for(E=0;E<F;E++){if(!n[(E/K)>>0]){for(T=0;T<aa;T++){if(Q[T].getAt(E)){Q[T].getAt(E).hide(true)}}}}}s.renderLabels();s.renderCallouts()},onCreateLabel:function(g,l,e,h){var j=this,k=j.labelsGroup,a=j.label,d=j.centerX,c=j.centerY,m=l.middle,b=Ext.apply(j.seriesLabelStyle||{},a||{});return j.chart.surface.add(Ext.apply({type:"text","text-anchor":"middle",group:k,x:m.x,y:m.y},b))},onPlaceLabel:function(k,p,z,t,s,e,g){var B=this,q=B.chart,w=q.resizing,A=B.label,u=A.renderer,c=[].concat(A.field),m=B.centerX,l=B.centerY,C=z.middle,b={x:C.x,y:C.y},o=C.x-m,n=C.y-l,r={},d=1,j=Math.atan2(n,o||1),v=j*180/Math.PI,h;b.hidden=false;if(this.__excludes&&this.__excludes[t]){b.hidden=true}function a(i){if(i<0){i+=360}return i%360}k.setAttributes({text:u(p.get(c[g]))},true);switch(s){case"outside":d=Math.sqrt(o*o+n*n)*2;b.x=d*Math.cos(j)+m;b.y=d*Math.sin(j)+l;break;case"rotate":v=a(v);v=(v>90&&v<270)?v+180:v;h=k.attr.rotation.degrees;if(h!=null&&Math.abs(h-v)>180*0.5){if(v>h){v-=360}else{v+=360}v=v%360}else{v=a(v)}b.rotate={degrees:v,x:b.x,y:b.y};break;default:break}b.translate={x:0,y:0};if(e&&!w&&(s!="rotate"||h!=null)){B.onAnimate(k,{to:b})}else{k.setAttributes(b,true)}k._from=r},onPlaceCallout:function(l,o,z,v,u,d,e){var A=this,q=A.chart,j=A.centerX,h=A.centerY,B=z.middle,b={x:B.x,y:B.y},m=B.x-j,k=B.y-h,c=1,n,g=Math.atan2(k,m||1),a=l.label.getBBox(),w=20,t=10,s=10,r;c=z.endRho+w;n=(z.endRho+z.startRho)/2+(z.endRho-z.startRho)/3;b.x=c*Math.cos(g)+j;b.y=c*Math.sin(g)+h;m=n*Math.cos(g);k=n*Math.sin(g);if(q.animate){A.onAnimate(l.lines,{to:{path:["M",m+j,k+h,"L",b.x,b.y,"Z","M",b.x,b.y,"l",m>0?t:-t,0,"z"]}});A.onAnimate(l.box,{to:{x:b.x+(m>0?t:-(t+a.width+2*s)),y:b.y+(k>0?(-a.height-s/2):(-a.height-s/2)),width:a.width+2*s,height:a.height+2*s}});A.onAnimate(l.label,{to:{x:b.x+(m>0?(t+s):-(t+a.width+s)),y:b.y+(k>0?-a.height/4:-a.height/4)}})}else{l.lines.setAttributes({path:["M",m+j,k+h,"L",b.x,b.y,"Z","M",b.x,b.y,"l",m>0?t:-t,0,"z"]},true);l.box.setAttributes({x:b.x+(m>0?t:-(t+a.width+2*s)),y:b.y+(k>0?(-a.height-s/2):(-a.height-s/2)),width:a.width+2*s,height:a.height+2*s},true);l.label.setAttributes({x:b.x+(m>0?(t+s):-(t+a.width+s)),y:b.y+(k>0?-a.height/4:-a.height/4)},true)}for(r in l){l[r].show(true)}},onAnimate:function(b,a){b.show();return this.callParent(arguments)},isItemInPoint:function(l,j,n,e){var h=this,d=h.centerX,c=h.centerY,p=Math.abs,o=p(l-d),m=p(j-c),g=n.startAngle,a=n.endAngle,k=Math.sqrt(o*o+m*m),b=Math.atan2(j-c,l-d)/h.rad;if(b>h.firstAngle){b-=h.accuracy}return(b<=g&&b>a&&k>=n.startRho&&k<=n.endRho)},hideAll:function(c){var g,b,j,h,e,a,d;c=(isNaN(this._index)?c:this._index)||0;this.__excludes=this.__excludes||[];this.__excludes[c]=true;d=this.slices[c].sprite;for(e=0,a=d.length;e<a;e++){d[e].setAttributes({hidden:true},true)}if(this.slices[c].shadowAttrs){for(g=0,h=this.slices[c].shadowAttrs,b=h.length;g<b;g++){j=h[g];for(e=0,a=j.length;e<a;e++){j[e].setAttributes({hidden:true},true)}}}this.drawSeries()},showAll:function(a){a=(isNaN(this._index)?a:this._index)||0;this.__excludes[a]=false;this.drawSeries()},highlightItem:function(s){var u=this,t=u.rad,w,d,o,q,a,e,k,b,m,c,g,p,h,v,n,l,j;s=s||this.items[this._index];this.unHighlightItem();if(!s||u.animating||(s.sprite&&s.sprite._animating)){return}u.callParent([s]);if(!u.highlight){return}if("segment" in u.highlightCfg){w=u.highlightCfg.segment;d=u.chart.animate;if(u.labelsGroup){g=u.labelsGroup;p=u.label.display;h=g.getAt(s.index);v=(s.startAngle+s.endAngle)/2*t;n=w.margin||0;l=n*Math.cos(v);j=n*Math.sin(v);if(Math.abs(l)<1e-10){l=0}if(Math.abs(j)<1e-10){j=0}if(d){h.stopAnimation();h.animate({to:{translate:{x:l,y:j}},duration:u.highlightDuration})}else{h.setAttributes({translate:{x:l,y:j}},true)}}if(u.chart.shadow&&s.shadows){q=0;a=s.shadows;k=a.length;for(;q<k;q++){e=a[q];b={};m=s.sprite._from.segment;for(c in m){if(!(c in w)){b[c]=m[c]}}o={segment:Ext.applyIf(b,u.highlightCfg.segment)};if(d){e.stopAnimation();e.animate({to:o,duration:u.highlightDuration})}else{e.setAttributes(o,true)}}}}},unHighlightItem:function(){var w=this,l,e,d,k,t,s,r,q,x,m,c,a,v,n,b,g,u,h,o;if(!w.highlight){return}if(("segment" in w.highlightCfg)&&w.items){l=w.items;e=w.chart.animate;d=!!w.chart.shadow;k=w.labelsGroup;t=l.length;s=0;r=0;q=w.label.display;for(;s<t;s++){u=l[s];if(!u){continue}n=u.sprite;if(n&&n._highlighted){if(k){h=k.getAt(u.index);o=Ext.apply({translate:{x:0,y:0}},q=="rotate"?{rotate:{x:h.attr.x,y:h.attr.y,degrees:h.attr.rotation.degrees}}:{});if(e){h.stopAnimation();h.animate({to:o,duration:w.highlightDuration})}else{h.setAttributes(o,true)}}if(d){b=u.shadows;x=b.length;for(;r<x;r++){c={};a=u.sprite._to.segment;v=u.sprite._from.segment;Ext.apply(c,v);for(m in a){if(!(m in v)){c[m]=a[m]}}g=b[r];if(e){g.stopAnimation();g.animate({to:{segment:c},duration:w.highlightDuration})}else{g.setAttributes({segment:c},true)}}}}}}w.callParent(arguments)},getLegendColor:function(a){var b=this;return(b.colorSet&&b.colorSet[a%b.colorSet.length])||b.colorArrayStyle[a%b.colorArrayStyle.length]}});Ext.define("Ext.chart.series.Radar",{extend:"Ext.chart.series.Series",requires:["Ext.chart.Shape","Ext.fx.Anim"],type:"radar",alias:"series.radar",rad:Math.PI/180,showInLegend:false,style:{},constructor:function(c){this.callParent(arguments);var e=this,a=e.chart.surface,d,b;e.group=a.getGroup(e.seriesId);if(e.showMarkers){e.markerGroup=a.getGroup(e.seriesId+"-markers")}},drawSeries:function(){var w=this,c=w.chart.getChartStore(),S=c.data.items,T,I,z=w.group,B,U=w.chart,L=U.series.items,M,v,m,Q=U.animate,o=w.field||w.yField,K=U.surface,F=U.chartBBox,E=w.seriesIdx,j=w.colorArrayStyle,g,e,A,N,r=0,a=[],D=Math.max,k=Math.cos,t=Math.sin,q=Math.PI*2,P=c.getCount(),h,O,J,H,G,R,u,n=w.seriesStyle,b=w.seriesLabelStyle,p=U.resizing||!w.radar,C=U.axes&&U.axes.get(0),V=!(C&&C.maximum);w.setBBox();r=V?0:(C.maximum||0);Ext.apply(n,w.style||{});if(!c||!c.getCount()||w.seriesIsHidden){w.hide();w.items=[];if(w.radar){w.radar.hide(true)}w.radar=null;return}if(!n.stroke){n.stroke=j[E%j.length]}w.unHighlightItem();w.cleanHighlights();g=w.centerX=F.x+(F.width/2);e=w.centerY=F.y+(F.height/2);w.radius=N=Math.min(F.width,F.height)/2;w.items=A=[];if(V){for(M=0,v=L.length;M<v;M++){m=L[M];a.push(m.yField)}for(T=0;T<P;T++){I=S[T];for(R=0,u=a.length;R<u;R++){r=D(+I.get(a[R]),r)}}}r=r||1;h=[];O=[];for(R=0;R<P;R++){I=S[R];G=N*I.get(o)/r;J=G*k(R/P*q);H=G*t(R/P*q);if(R==0){O.push("M",J+g,H+e);h.push("M",0.01*J+g,0.01*H+e)}else{O.push("L",J+g,H+e);h.push("L",0.01*J+g,0.01*H+e)}A.push({sprite:false,point:[g+J,e+H],storeItem:I,series:w})}O.push("Z");if(!w.radar){w.radar=K.add(Ext.apply({type:"path",group:z,path:h},n||{}))}if(U.resizing){w.radar.setAttributes({path:h},true)}if(U.animate){w.onAnimate(w.radar,{to:Ext.apply({path:O},n||{})})}else{w.radar.setAttributes(Ext.apply({path:O},n||{}),true)}if(w.showMarkers){w.drawMarkers()}w.renderLabels();w.renderCallouts()},drawMarkers:function(){var n=this,k=n.chart,a=k.surface,b=Ext.apply({},n.markerStyle||{}),j=Ext.apply(b,n.markerConfig,{fill:n.colorArrayStyle[n.seriesIdx%n.colorArrayStyle.length]}),m=n.items,o=j.type,q=n.markerGroup,e=n.centerX,d=n.centerY,p,h,c,g;delete j.type;for(h=0,c=m.length;h<c;h++){p=m[h];g=q.getAt(h);if(!g){g=Ext.chart.Shape[o](a,Ext.apply({group:q,x:0,y:0,translate:{x:e,y:d}},j))}else{g.show()}p.sprite=g;if(k.resizing){g.setAttributes({x:0,y:0,translate:{x:e,y:d}},true)}g._to={translate:{x:p.point[0],y:p.point[1]}};if(k.animate){n.onAnimate(g,{to:g._to})}else{g.setAttributes(Ext.apply(g._to,j||{}),true)}}},isItemInPoint:function(c,g,e){var b,d=10,a=Math.abs;b=e.point;return(a(b[0]-c)<=d&&a(b[1]-g)<=d)},onCreateLabel:function(g,m,e,h){var j=this,l=j.labelsGroup,a=j.label,d=j.centerX,c=j.centerY,k=m.point,b=Ext.apply(j.seriesLabelStyle||{},a);return j.chart.surface.add(Ext.apply({type:"text","text-anchor":"middle",group:l,x:d,y:c},a||{}))},onPlaceLabel:function(q,h,s,g,k,b){var m=this,l=m.chart,j=l.resizing,c=m.label,r=c.renderer,p=c.field,e=m.centerX,d=m.centerY,a={x:s.point[0],y:s.point[1]},o=a.x-e,n=a.y-d;q.setAttributes({text:r(h.get(p)),hidden:true},true);if(j){q.setAttributes({x:e,y:d},true)}if(b){q.show(true);m.onAnimate(q,{to:a})}else{q.setAttributes(a,true);q.show(true)}},toggleAll:function(a){var e=this,b,d,g,c;if(!a){Ext.chart.series.Radar.superclass.hideAll.call(e)}else{Ext.chart.series.Radar.superclass.showAll.call(e)}if(e.radar){e.radar.setAttributes({hidden:!a},true);if(e.radar.shadows){for(b=0,c=e.radar.shadows,d=c.length;b<d;b++){g=c[b];g.setAttributes({hidden:!a},true)}}}},hideAll:function(){this.toggleAll(false);this.hideMarkers(0)},showAll:function(){this.toggleAll(true)},hideMarkers:function(a){var d=this,c=d.markerGroup&&d.markerGroup.getCount()||0,b=a||0;for(;b<c;b++){d.markerGroup.getAt(b).hide(true)}}});Ext.define("Ext.chart.series.Scatter",{extend:"Ext.chart.series.Cartesian",requires:["Ext.chart.axis.Axis","Ext.chart.Shape","Ext.fx.Anim"],type:"scatter",alias:"series.scatter",constructor:function(c){this.callParent(arguments);var e=this,g=e.chart.shadow,a=e.chart.surface,d,b;Ext.apply(e,c,{style:{},markerConfig:{},shadowAttributes:[{"stroke-width":6,"stroke-opacity":0.05,stroke:"rgb(0, 0, 0)"},{"stroke-width":4,"stroke-opacity":0.1,stroke:"rgb(0, 0, 0)"},{"stroke-width":2,"stroke-opacity":0.15,stroke:"rgb(0, 0, 0)"}]});e.group=a.getGroup(e.seriesId);if(g){for(d=0,b=e.shadowAttributes.length;d<b;d++){e.shadowGroups.push(a.getGroup(e.seriesId+"-shadows"+d))}}},getBounds:function(){var s=this,j=s.chart,d=j.getChartStore(),o=j.axes,l=s.getAxesForXAndYFields(),k=l.xAxis,e=l.yAxis,a,t,c,g,r,p,q,n,m,b,h;s.setBBox();a=s.bbox;if(b=o.get(k)){h=b.applyData();r=h.from;q=h.to}if(b=o.get(e)){h=b.applyData();p=h.from;n=h.to}if(s.xField&&!Ext.isNumber(r)){b=s.getMinMaxXValues();r=b[0];q=b[1]}if(s.yField&&!Ext.isNumber(p)){b=s.getMinMaxYValues();p=b[0];n=b[1]}if(isNaN(r)){r=0;q=d.getCount()-1;t=a.width/(d.getCount()-1)}else{t=a.width/(q-r)}if(isNaN(p)){p=0;n=d.getCount()-1;c=a.height/(d.getCount()-1)}else{c=a.height/(n-p)}return{bbox:a,minX:r,minY:p,xScale:t,yScale:c}},getPaths:function(){var z=this,n=z.chart,b=n.shadow,e=n.getChartStore(),B=e.data.items,s,l,d,j=z.group,g=z.bounds=z.getBounds(),a=z.bbox,C=g.xScale,c=g.yScale,v=g.minX,u=g.minY,A=a.x,w=a.y,h=a.height,o=z.items=[],q=[],m,k,r,t,p;for(s=0,l=B.length;s<l;s++){d=B[s];r=d.get(z.xField);t=d.get(z.yField);if(typeof t=="undefined"||(typeof t=="string"&&!t)||r==null||t==null){continue}if(typeof r=="string"||typeof r=="object"&&!Ext.isDate(r)){r=s}if(typeof t=="string"||typeof t=="object"&&!Ext.isDate(t)){t=s}m=A+(r-v)*C;k=w+h-(t-u)*c;q.push({x:m,y:k});z.items.push({series:z,value:[r,t],point:[m,k],storeItem:d});if(n.animate&&n.resizing){p=j.getAt(s);if(p){z.resetPoint(p);if(b){z.resetShadow(p)}}}}return q},resetPoint:function(a){var b=this.bbox;a.setAttributes({translate:{x:(b.x+b.width)/2,y:(b.y+b.height)/2}},true)},resetShadow:function(c){var g=this,e=c.shadows,j=g.shadowAttributes,d=g.shadowGroups.length,h=g.bbox,b,a;for(b=0;b<d;b++){a=Ext.apply({},j[b]);if(a.translate){a.translate.x+=(h.x+h.width)/2;a.translate.y+=(h.y+h.height)/2}else{a.translate={x:(h.x+h.width)/2,y:(h.y+h.height)/2}}e[b].setAttributes(a,true)}},createPoint:function(a,c){var d=this,b=d.chart,e=d.group,g=d.bbox;return Ext.chart.Shape[c](b.surface,Ext.apply({},{x:0,y:0,group:e,translate:{x:(g.x+g.width)/2,y:(g.y+g.height)/2}},a))},createShadow:function(n,g,k){var j=this,h=j.chart,l=j.shadowGroups,d=j.shadowAttributes,a=l.length,o=j.bbox,c,m,b,e;n.shadows=b=[];for(c=0;c<a;c++){e=Ext.apply({},d[c]);if(e.translate){e.translate.x+=(o.x+o.width)/2;e.translate.y+=(o.y+o.height)/2}else{Ext.apply(e,{translate:{x:(o.x+o.width)/2,y:(o.y+o.height)/2}})}Ext.apply(e,g);m=Ext.chart.Shape[k](h.surface,Ext.apply({},{x:0,y:0,group:l[c]},e));b.push(m)}},drawSeries:function(){var u=this,l=u.chart,h=l.getChartStore(),j=u.group,c=l.shadow,a=u.shadowGroups,q=u.shadowAttributes,r=a.length,m,n,o,k,p,t,e,g,b,d,s;t=Ext.apply(u.markerStyle,u.markerConfig);g=t.type;delete t.type;if(!h||!h.getCount()){u.hide();u.items=[];return}u.unHighlightItem();u.cleanHighlights();n=u.getPaths();k=n.length;for(p=0;p<k;p++){o=n[p];m=j.getAt(p);Ext.apply(o,t);if(!m){m=u.createPoint(o,g);if(c){u.createShadow(m,t,g)}}b=m.shadows;if(l.animate){d=u.renderer(m,h.getAt(p),{translate:o},p,h);m._to=d;u.onAnimate(m,{to:d});for(e=0;e<r;e++){s=Ext.apply({},q[e]);d=u.renderer(b[e],h.getAt(p),Ext.apply({},{hidden:false,translate:{x:o.x+(s.translate?s.translate.x:0),y:o.y+(s.translate?s.translate.y:0)}},s),p,h);u.onAnimate(b[e],{to:d})}}else{d=u.renderer(m,h.getAt(p),{translate:o},p,h);m._to=d;m.setAttributes(d,true);for(e=0;e<r;e++){s=Ext.apply({},q[e]);d=u.renderer(b[e],h.getAt(p),Ext.apply({},{hidden:false,translate:{x:o.x+(s.translate?s.translate.x:0),y:o.y+(s.translate?s.translate.y:0)}},s),p,h);b[e].setAttributes(d,true)}}u.items[p].sprite=m}k=j.getCount();for(p=n.length;p<k;p++){j.getAt(p).hide(true)}u.renderLabels();u.renderCallouts()},onCreateLabel:function(d,k,c,e){var g=this,h=g.labelsGroup,a=g.label,b=Ext.apply({},a,g.seriesLabelStyle),j=g.bbox;return g.chart.surface.add(Ext.apply({type:"text",group:h,x:k.point[0],y:j.y+j.height/2},b))},onPlaceLabel:function(g,k,t,q,p,d){var v=this,l=v.chart,s=l.resizing,u=v.label,r=u.renderer,b=u.field,a=v.bbox,j=t.point[0],h=t.point[1],c=t.sprite.attr.radius,e,n,m,o;g.setAttributes({text:r(k.get(b)),hidden:true},true);if(p=="rotate"){g.setAttributes({"text-anchor":"start",rotation:{x:j,y:h,degrees:-45}},true);e=g.getBBox();n=e.width;m=e.height;j=j<a.x?a.x:j;j=(j+n>a.x+a.width)?(j-(j+n-a.x-a.width)):j;h=(h-m<a.y)?a.y+m:h}else{if(p=="under"||p=="over"){e=t.sprite.getBBox();e.width=e.width||(c*2);e.height=e.height||(c*2);h=h+(p=="over"?-e.height:e.height);e=g.getBBox();n=e.width/2;m=e.height/2;j=j-n<a.x?a.x+n:j;j=(j+n>a.x+a.width)?(j-(j+n-a.x-a.width)):j;h=h-m<a.y?a.y+m:h;h=(h+m>a.y+a.height)?(h-(h+m-a.y-a.height)):h}}if(!l.animate){g.setAttributes({x:j,y:h},true);g.show(true)}else{if(s){o=t.sprite.getActiveAnimation();if(o){o.on("afteranimate",function(){g.setAttributes({x:j,y:h},true);g.show(true)})}else{g.show(true)}}else{v.onAnimate(g,{to:{x:j,y:h}})}}},onPlaceCallout:function(k,m,B,z,w,c,h){var E=this,n=E.chart,u=n.surface,A=n.resizing,D=E.callouts,o=E.items,b=B.point,F,a=k.label.getBBox(),C=30,t=10,s=3,e,d,g,r,q,v=E.bbox,l,j;F=[Math.cos(Math.PI/4),-Math.sin(Math.PI/4)];l=b[0]+F[0]*C;j=b[1]+F[1]*C;e=l+(F[0]>0?0:-(a.width+2*s));d=j-a.height/2-s;g=a.width+2*s;r=a.height+2*s;if(e<v[0]||(e+g)>(v[0]+v[2])){F[0]*=-1}if(d<v[1]||(d+r)>(v[1]+v[3])){F[1]*=-1}l=b[0]+F[0]*C;j=b[1]+F[1]*C;e=l+(F[0]>0?0:-(a.width+2*s));d=j-a.height/2-s;g=a.width+2*s;r=a.height+2*s;if(n.animate){E.onAnimate(k.lines,{to:{path:["M",b[0],b[1],"L",l,j,"Z"]}},true);E.onAnimate(k.box,{to:{x:e,y:d,width:g,height:r}},true);E.onAnimate(k.label,{to:{x:l+(F[0]>0?s:-(a.width+s)),y:j}},true)}else{k.lines.setAttributes({path:["M",b[0],b[1],"L",l,j,"Z"]},true);k.box.setAttributes({x:e,y:d,width:g,height:r},true);k.label.setAttributes({x:l+(F[0]>0?s:-(a.width+s)),y:j},true)}for(q in k){k[q].show(true)}},onAnimate:function(b,a){b.show();return this.callParent(arguments)},isItemInPoint:function(c,h,e){var b,d=10,a=Math.abs;function g(i){var k=a(i[0]-c),j=a(i[1]-h);return Math.sqrt(k*k+j*j)}b=e.point;return(b[0]-d<=c&&b[0]+d>=c&&b[1]-d<=h&&b[1]+d>=h)}});Ext.define("Ext.layout.container.Table",{alias:["layout.table"],extend:"Ext.layout.container.Container",alternateClassName:"Ext.layout.TableLayout",monitorResize:false,type:"table",clearEl:true,targetCls:Ext.baseCSSPrefix+"table-layout-ct",tableCls:Ext.baseCSSPrefix+"table-layout",cellCls:Ext.baseCSSPrefix+"table-layout-cell",tableAttrs:null,itemSizePolicy:{setsWidth:0,setsHeight:0},getItemSizePolicy:function(a){return this.itemSizePolicy},getLayoutItems:function(){var g=this,b=[],c=g.callParent(),e,a=c.length,d;for(d=0;d<a;d++){e=c[d];if(!e.hidden){b.push(e)}}return b},renderChildren:function(){var j=this,h=j.getLayoutItems(),e=j.owner.getTargetEl().child("table",true).tBodies[0],p=e.rows,d=0,g=h.length,o,m,c,a,n,l,k,b;o=j.calculateCells(h);for(;d<g;d++){m=o[d];c=m.rowIdx;a=m.cellIdx;n=h[d];l=p[c];if(!l){l=e.insertRow(c);if(j.trAttrs){l.set(j.trAttrs)}}b=k=Ext.get(l.cells[a]||l.insertCell(a));if(j.needsDivWrap()){b=k.first()||k.createChild({tag:"div"});b.setWidth(null)}if(!n.rendered){j.renderItem(n,b,0)}else{if(!j.isValidParent(n,b,c,a,e)){j.moveItem(n,b,0)}}if(j.tdAttrs){k.set(j.tdAttrs)}if(n.tdAttrs){k.set(n.tdAttrs)}k.set({colSpan:n.colspan||1,rowSpan:n.rowspan||1,id:n.cellId||"",cls:j.cellCls+" "+(n.cellCls||"")});if(!o[d+1]||o[d+1].rowIdx!==c){a++;while(l.cells[a]){l.deleteCell(a)}}}c++;while(e.rows[c]){e.deleteRow(c)}},calculate:function(g){if(!g.hasDomProp("containerChildrenDone")){this.done=false}else{var c=g.targetContext,b=g.widthModel.shrinkWrap,a=g.heightModel.shrinkWrap,h=a||b,d=h&&c.el.child("table",true),e=h&&c.getPaddingInfo();if(b){g.setContentWidth(d.offsetWidth+e.width,true)}if(a){g.setContentHeight(d.offsetHeight+e.height,true)}}},finalizeLayout:function(){if(this.needsDivWrap()){var b=this.getLayoutItems(),c,a=b.length,d;for(c=0;c<a;c++){d=b[c];Ext.fly(d.el.dom.parentNode).setWidth(d.getWidth())}}if(Ext.isIE6||(Ext.isIEQuirks)){this.owner.getTargetEl().child("table").repaint()}},calculateCells:function(k){var m=[],b=0,d=0,a=0,h=this.columns||Infinity,n=[],e=0,c,g=k.length,l;for(;e<g;e++){l=k[e];while(d>=h||n[d]>0){if(d>=h){d=0;a=0;b++;for(c=0;c<h;c++){if(n[c]>0){n[c]--}}}else{d++}}m.push({rowIdx:b,cellIdx:a});for(c=l.colspan||1;c;--c){n[d]=l.rowspan||1;++d}++a}return m},getRenderTree:function(){var k=this,h=k.getLayoutItems(),o,p=[],q=Ext.apply({tag:"table",role:"presentation",cls:k.tableCls,cellspacing:0,cn:{tag:"tbody",cn:p}},k.tableAttrs),c=k.tdAttrs,d=k.needsDivWrap(),e,g=h.length,n,m,j,b,a,l;o=k.calculateCells(h);for(e=0;e<g;e++){n=h[e];m=o[e];b=m.rowIdx;a=m.cellIdx;j=p[b];if(!j){j=p[b]={tag:"tr",cn:[]};if(k.trAttrs){Ext.apply(j,k.trAttrs)}}l=j.cn[a]={tag:"td"};if(c){Ext.apply(l,c)}Ext.apply(l,{colSpan:n.colspan||1,rowSpan:n.rowspan||1,id:n.cellId||"",cls:k.cellCls+" "+(n.cellCls||"")});if(d){l=l.cn={tag:"div"}}k.configureItem(n);l.cn=n.getRenderTree()}return q},isValidParent:function(g,h,e,d){var b,a,c;if(arguments.length===3){c=g.el.up("table");return c&&c.dom.parentNode===h.dom}b=this.owner.getTargetEl().child("table",true).tBodies[0];a=b.rows[e].cells[d];return g.el.dom.parentNode===a},needsDivWrap:function(){return Ext.isOpera10_5}});Ext.define("Ext.container.ButtonGroup",{extend:"Ext.panel.Panel",alias:"widget.buttongroup",alternateClassName:"Ext.ButtonGroup",requires:["Ext.layout.container.Table"],baseCls:Ext.baseCSSPrefix+"btn-group",layout:{type:"table"},defaultType:"button",frame:true,frameHeader:false,titleAlign:"center",initComponent:function(){var a=this,b=a.columns;a.noTitleCls=a.baseCls+"-notitle";if(b){a.layout=Ext.apply({},{columns:b},a.layout)}if(!a.title){a.addCls(a.noTitleCls)}a.callParent(arguments)},onBeforeAdd:function(a){if(a.isButton){a.ui=a.ui+"-toolbar"}this.callParent(arguments)},applyDefaults:function(a){if(!Ext.isString(a)){a=this.callParent(arguments)}return a}});Ext.define("Ext.container.Viewport",{extend:"Ext.container.Container",alias:"widget.viewport",requires:["Ext.EventManager"],alternateClassName:"Ext.Viewport",isViewport:true,ariaRole:"application",preserveElOnDestroy:true,initComponent:function(){var c=this,a=document.body.parentNode,b;Ext.getScrollbarSize();c.width=c.height=undefined;c.callParent(arguments);Ext.fly(a).addCls(Ext.baseCSSPrefix+"viewport");if(c.autoScroll){delete c.autoScroll;Ext.fly(a).setStyle("overflow","auto")}c.el=b=Ext.getBody();b.setHeight=Ext.emptyFn;b.setWidth=Ext.emptyFn;b.setSize=Ext.emptyFn;b.dom.scroll="no";c.allowDomMove=false;c.renderTo=c.el},onRender:function(){var a=this;a.callParent(arguments);a.width=Ext.Element.getViewportWidth();a.height=Ext.Element.getViewportHeight()},afterFirstLayout:function(){var a=this;a.callParent(arguments);setTimeout(function(){Ext.EventManager.onWindowResize(a.fireResize,a)},1)},fireResize:function(b,a){if(b!=this.width||a!=this.height){this.setSize(b,a)}}});Ext.define("Ext.data.proxy.Proxy",{alias:"proxy.proxy",alternateClassName:["Ext.data.DataProxy","Ext.data.Proxy"],uses:["Ext.data.Batch","Ext.data.Operation","Ext.data.Model"],mixins:{observable:"Ext.util.Observable"},batchOrder:"create,update,destroy",batchActions:true,defaultReaderType:"json",defaultWriterType:"json",isProxy:true,constructor:function(a){a=a||{};if(a.model===undefined){delete a.model}this.mixins.observable.constructor.call(this,a);if(this.model!==undefined&&!(this.model instanceof Ext.data.Model)){this.setModel(this.model)}},setModel:function(b,c){this.model=Ext.ModelManager.getModel(b);var a=this.reader,d=this.writer;this.setReader(a);this.setWriter(d);if(c&&this.store){this.store.setModel(this.model)}},getModel:function(){return this.model},setReader:function(a){var c=this,b=true;if(a===undefined||typeof a=="string"){a={type:a};b=false}if(a.isReader){a.setModel(c.model)}else{if(b){a=Ext.apply({},a)}Ext.applyIf(a,{proxy:c,model:c.model,type:c.defaultReaderType});a=Ext.createByAlias("reader."+a.type,a)}if(a.onMetaChange){a.onMetaChange=Ext.Function.createSequence(a.onMetaChange,this.onMetaChange,this)}c.reader=a;return c.reader},getReader:function(){return this.reader},onMetaChange:function(a){this.fireEvent("metachange",this,a)},setWriter:function(c){var b=this,a=true;if(c===undefined||typeof c=="string"){c={type:c};a=false}if(!c.isWriter){if(a){c=Ext.apply({},c)}Ext.applyIf(c,{model:b.model,type:b.defaultWriterType});c=Ext.createByAlias("writer."+c.type,c)}b.writer=c;return b.writer},getWriter:function(){return this.writer},create:Ext.emptyFn,read:Ext.emptyFn,update:Ext.emptyFn,destroy:Ext.emptyFn,batch:function(o,l){var k=this,j=k.batchActions,h,c,g,d,e,m,b,n,i;if(o.operations===undefined){o={operations:o,listeners:l}}if(o.batch){if(Ext.isDefined(o.batch.runOperation)){h=Ext.applyIf(o.batch,{proxy:k,listeners:{}})}}else{o.batch={proxy:k,listeners:o.listeners||{}}}if(!h){h=new Ext.data.Batch(o.batch)}h.on("complete",Ext.bind(k.onBatchComplete,k,[o],0));g=k.batchOrder.split(",");d=g.length;for(m=0;m<d;m++){e=g[m];c=o.operations[e];if(c){if(j){h.add(new Ext.data.Operation({action:e,records:c}))}else{n=c.length;for(b=0;b<n;b++){i=c[b];h.add(new Ext.data.Operation({action:e,records:[i]}))}}}}h.start();return h},onBatchComplete:function(a,b){var c=a.scope||this;if(b.hasException){if(Ext.isFunction(a.failure)){Ext.callback(a.failure,c,[b,a])}}else{if(Ext.isFunction(a.success)){Ext.callback(a.success,c,[b,a])}}if(Ext.isFunction(a.callback)){Ext.callback(a.callback,c,[b,a])}}},function(){Ext.data.DataProxy=this});Ext.define("Ext.data.AbstractStore",{requires:["Ext.util.MixedCollection","Ext.data.proxy.Proxy","Ext.data.Operation","Ext.util.Filter"],mixins:{observable:"Ext.util.Observable",sortable:"Ext.util.Sortable"},statics:{create:function(a){if(!a.isStore){if(!a.type){a.type="store"}a=Ext.createByAlias("store."+a.type,a)}return a}},remoteSort:false,remoteFilter:false,autoLoad:undefined,autoSync:false,batchUpdateMode:"operation",filterOnLoad:true,sortOnLoad:true,implicitModel:false,defaultProxyType:"memory",isDestroyed:false,isStore:true,sortRoot:"data",constructor:function(a){var c=this,b;Ext.apply(c,a);c.removed=[];c.mixins.observable.constructor.apply(c,arguments);c.model=Ext.ModelManager.getModel(c.model);Ext.applyIf(c,{modelDefaults:{}});if(!c.model&&c.fields){c.model=Ext.define("Ext.data.Store.ImplicitModel-"+(c.storeId||Ext.id()),{extend:"Ext.data.Model",fields:c.fields,proxy:c.proxy||c.defaultProxyType});delete c.fields;c.implicitModel=true}c.setProxy(c.proxy||c.model.getProxy());c.proxy.on("metachange",c.onMetaChange,c);if(c.id&&!c.storeId){c.storeId=c.id;delete c.id}if(c.storeId){Ext.data.StoreManager.register(c)}c.mixins.sortable.initSortable.call(c);b=c.decodeFilters(c.filters);c.filters=new Ext.util.MixedCollection();c.filters.addAll(b)},setProxy:function(a){var b=this;if(a instanceof Ext.data.proxy.Proxy){a.setModel(b.model)}else{if(Ext.isString(a)){a={type:a}}Ext.applyIf(a,{model:b.model});a=Ext.createByAlias("proxy."+a.type,a)}b.proxy=a;return b.proxy},getProxy:function(){return this.proxy},onMetaChange:function(a,b){this.fireEvent("metachange",this,b)},create:function(e,c){var d=this,a=Ext.ModelManager.create(Ext.applyIf(e,d.modelDefaults),d.model.modelName),b;c=c||{};Ext.applyIf(c,{action:"create",records:[a]});b=new Ext.data.Operation(c);d.proxy.create(b,d.onProxyWrite,d);return a},read:function(){return this.load.apply(this,arguments)},update:function(b){var c=this,a;b=b||{};Ext.applyIf(b,{action:"update",records:c.getUpdatedRecords()});a=new Ext.data.Operation(b);return c.proxy.update(a,c.onProxyWrite,c)},onProxyWrite:function(b){var c=this,d=b.wasSuccessful(),a=b.getRecords();switch(b.action){case"create":c.onCreateRecords(a,b,d);break;case"update":c.onUpdateRecords(a,b,d);break;case"destroy":c.onDestroyRecords(a,b,d);break}if(d){c.fireEvent("write",c,b);c.fireEvent("datachanged",c);c.fireEvent("refresh",c)}Ext.callback(b.callback,b.scope||c,[a,b,d])},onCreateRecords:Ext.emptyFn,onUpdateRecords:Ext.emptyFn,onDestroyRecords:function(b,a,c){if(c){this.removed=[]}},destroy:function(b){var c=this,a;b=b||{};Ext.applyIf(b,{action:"destroy",records:c.getRemovedRecords()});a=new Ext.data.Operation(b);return c.proxy.destroy(a,c.onProxyWrite,c)},onBatchOperationComplete:function(b,a){return this.onProxyWrite(a)},onBatchComplete:function(c,a){var g=this,b=c.operations,e=b.length,d;g.suspendEvents();for(d=0;d<e;d++){g.onProxyWrite(b[d])}g.resumeEvents();g.fireEvent("datachanged",g);g.fireEvent("refresh",g)},onBatchException:function(b,a){},filterNew:function(a){return a.phantom===true&&a.isValid()},getNewRecords:function(){return[]},getUpdatedRecords:function(){return[]},getModifiedRecords:function(){return[].concat(this.getNewRecords(),this.getUpdatedRecords())},filterUpdated:function(a){return a.dirty===true&&a.phantom!==true&&a.isValid()},getRemovedRecords:function(){return this.removed},filter:function(a,b){},decodeFilters:function(e){if(!Ext.isArray(e)){if(e===undefined){e=[]}else{e=[e]}}var d=e.length,a=Ext.util.Filter,b,c;for(c=0;c<d;c++){b=e[c];if(!(b instanceof a)){Ext.apply(b,{root:"data"});if(b.fn){b.filterFn=b.fn}if(typeof b=="function"){b={filterFn:b}}e[c]=new a(b)}}return e},clearFilter:function(a){},isFiltered:function(){},filterBy:function(b,a){},sync:function(c){var e=this,b={},g=e.getNewRecords(),d=e.getUpdatedRecords(),a=e.getRemovedRecords(),h=false;if(g.length>0){b.create=g;h=true}if(d.length>0){b.update=d;h=true}if(a.length>0){b.destroy=a;h=true}if(h&&e.fireEvent("beforesync",b)!==false){c=c||{};e.proxy.batch(Ext.apply(c,{operations:b,listeners:e.getBatchListeners()}))}return e},getBatchListeners:function(){var b=this,a={scope:b,exception:b.onBatchException};if(b.batchUpdateMode=="operation"){a.operationcomplete=b.onBatchOperationComplete}else{a.complete=b.onBatchComplete}return a},save:function(){return this.sync.apply(this,arguments)},load:function(b){var c=this,a;b=Ext.apply({action:"read",filters:c.filters.items,sorters:c.getSorters()},b);c.lastOptions=b;a=new Ext.data.Operation(b);if(c.fireEvent("beforeload",c,a)!==false){c.loading=true;c.proxy.read(a,c.onProxyLoad,c)}return c},reload:function(a){return this.load(Ext.apply(this.lastOptions,a))},afterEdit:function(a,e){var d=this,b,c;if(d.autoSync&&!d.autoSyncSuspended){for(b=e.length;b--;){if(a.fields.get(e[b]).persist){c=true;break}}if(c){d.sync()}}d.fireEvent("update",d,a,Ext.data.Model.EDIT,e)},afterReject:function(a){this.fireEvent("update",this,a,Ext.data.Model.REJECT,null)},afterCommit:function(a){this.fireEvent("update",this,a,Ext.data.Model.COMMIT,null)},destroyStore:function(){var a=this;if(!a.isDestroyed){if(a.storeId){Ext.data.StoreManager.unregister(a)}a.clearData();a.data=a.tree=a.sorters=a.filters=a.groupers=null;if(a.reader){a.reader.destroyReader()}a.proxy=a.reader=a.writer=null;a.clearListeners();a.isDestroyed=true;if(a.implicitModel){Ext.destroy(a.model)}else{a.model=null}}},doSort:function(a){var b=this;if(b.remoteSort){b.load()}else{b.data.sortBy(a);b.fireEvent("datachanged",b);b.fireEvent("refresh",b)}},clearData:Ext.emptyFn,getCount:Ext.emptyFn,getById:Ext.emptyFn,removeAll:Ext.emptyFn,isLoading:function(){return !!this.loading},suspendAutoSync:function(){this.autoSyncSuspended=true},resumeAutoSync:function(){this.autoSyncSuspended=false}});Ext.define("Ext.data.ResultSet",{loaded:true,count:0,total:0,success:false,constructor:function(a){Ext.apply(this,a);this.totalRecords=this.total;if(a.count===undefined){this.count=this.records.length}}});Ext.define("Ext.data.reader.Reader",{requires:["Ext.data.ResultSet","Ext.XTemplate"],alternateClassName:["Ext.data.Reader","Ext.data.DataReader"],mixins:{observable:"Ext.util.Observable"},totalProperty:"total",successProperty:"success",root:"",implicitIncludes:true,readRecordsOnFailure:true,isReader:true,applyDefaults:true,lastFieldGeneration:null,constructor:function(a){var b=this;b.mixins.observable.constructor.call(b,a);b.fieldCount=0;b.model=Ext.ModelManager.getModel(b.model);b.accessExpressionFn=Ext.Function.bind(b.createFieldAccessExpression,b);if(b.model&&b.model.prototype.fields){b.buildExtractors()}this.addEvents("exception")},setModel:function(a,c){var b=this;b.model=Ext.ModelManager.getModel(a);b.buildExtractors(true);if(c&&b.proxy){b.proxy.setModel(b.model,true)}},read:function(a){var b;if(a){b=a.responseText?this.getResponseData(a):this.readRecords(a)}return b||this.nullResultSet},readRecords:function(c){var d=this,i,b,a,g,e,h,j;if(d.lastFieldGeneration!==d.model.prototype.fields.generation){d.buildExtractors(true)}d.rawData=c;c=d.getData(c);i=true;b=0;a=[];if(d.successProperty){h=d.getSuccess(c);if(h===false||h==="false"){i=false}}if(d.messageProperty){j=d.getMessage(c)}if(d.readRecordsOnFailure||i){g=Ext.isArray(c)?c:d.getRoot(c);if(g){e=g.length}if(d.totalProperty){h=parseInt(d.getTotal(c),10);if(!isNaN(h)){e=h}}if(g){a=d.extractData(g);b=a.length}}return new Ext.data.ResultSet({total:e||b,count:b,records:a,success:i,message:j})},extractData:function(k){var j=this,d=[],b=j.model,a=k.length,e,c,h,g;if(!k.length&&Ext.isObject(k)){k=[k];a=1}for(g=0;g<a;g++){c=k[g];if(!c.isModel){h=new b(undefined,j.getId(c),c,e={});h.phantom=false;j.convertRecordData(e,c,h);d.push(h);if(j.implicitIncludes){j.readAssociated(h,c)}}else{d.push(c)}}return d},readAssociated:function(h,e){var d=h.associations.items,g=0,a=d.length,c,b,k,j;for(;g<a;g++){c=d[g];b=this.getAssociatedDataRoot(e,c.associationKey||c.name);if(b){j=c.getReader();if(!j){k=c.associatedModel.proxy;if(k){j=k.getReader()}else{j=new this.constructor({model:c.associatedName})}}c.read(h,j,b)}}},getAssociatedDataRoot:function(b,a){return b[a]},getFields:function(){return this.model.prototype.fields.items},getData:function(a){return a},getRoot:function(a){return a},getResponseData:function(a){},onMetaChange:function(e){var d=this,b=e.fields||d.getFields(),c,a;d.metaData=e;d.root=e.root||d.root;d.idProperty=e.idProperty||d.idProperty;d.totalProperty=e.totalProperty||d.totalProperty;d.successProperty=e.successProperty||d.successProperty;d.messageProperty=e.messageProperty||d.messageProperty;a=e.clientIdProperty;if(d.model){d.model.setFields(b,d.idProperty,a);d.setModel(d.model,true)}else{c=Ext.define("Ext.data.reader.Json-Model"+Ext.id(),{extend:"Ext.data.Model",fields:b,clientIdProperty:a});if(d.idProperty){c.idProperty=d.idProperty}d.setModel(c,true)}},getIdProperty:function(){return this.idProperty||this.model.prototype.idProperty},buildExtractors:function(b){var g=this,j=g.getIdProperty(),i=g.totalProperty,e=g.successProperty,h=g.messageProperty,d,c,a;if(b===true){delete g.convertRecordData}if(g.convertRecordData){return}if(i){g.getTotal=g.createAccessor(i)}if(e){g.getSuccess=g.createAccessor(e)}if(h){g.getMessage=g.createAccessor(h)}if(j){c=g.model.prototype.fields.get(j);if(c){a=c.mapping;j=(a!==undefined&&a!==null)?a:j}d=g.createAccessor(j);g.getId=function(k){var l=d.call(g,k);return(l===undefined||l==="")?null:l}}else{g.getId=function(){return null}}g.convertRecordData=g.buildRecordDataExtractor();g.lastFieldGeneration=g.model.prototype.fields.generation},recordDataExtractorTemplate:["var me = this\n","    ,fields = me.model.prototype.fields\n","    ,value\n","    ,internalId\n",'<tpl for="fields">','    ,__field{#} = fields.get("{name}")\n',"</tpl>",";\n","return function(dest, source, record) {\n",'<tpl for="fields">','    value = {[ this.createFieldAccessExpression(values, "__field" + xindex, "source") ]};\n','<tpl if="hasCustomConvert">','    dest["{name}"] = value === undefined ? __field{#}.convert(__field{#}.defaultValue, record) : __field{#}.convert(value, record);\n','<tpl elseif="defaultValue !== undefined">',"    if (value === undefined) {\n","        if (me.applyDefaults) {\n",'<tpl if="convert">','            dest["{name}"] = __field{#}.convert(__field{#}.defaultValue, record);\n',"<tpl else>",'            dest["{name}"] = __field{#}.defaultValue\n',"</tpl>","        };\n","    } else {\n",'<tpl if="convert">','        dest["{name}"] = __field{#}.convert(value, record);\n',"<tpl else>",'        dest["{name}"] = value;\n',"</tpl>","    };","<tpl else>","    if (value !== undefined) {\n",'<tpl if="convert">','        dest["{name}"] = __field{#}.convert(value, record);\n',"<tpl else>",'        dest["{name}"] = value;\n',"</tpl>","    }\n","</tpl>","</tpl>",'<tpl if="clientIdProp">','    if (record && (internalId = {[ this.createFieldAccessExpression({mapping: values.clientIdProp}, null, "source") ]})) {\n','        record.{["internalId"]} = internalId;\n',"    }\n","</tpl>","};"],buildRecordDataExtractor:function(){var c=this,a=c.model.prototype,b={clientIdProp:a.clientIdProperty,fields:a.fields.items};c.recordDataExtractorTemplate.createFieldAccessExpression=c.accessExpressionFn;return Ext.functionFactory(c.recordDataExtractorTemplate.apply(b)).call(c)},destroyReader:function(){var a=this;delete a.proxy;delete a.model;delete a.convertRecordData;delete a.getId;delete a.getTotal;delete a.getSuccess;delete a.getMessage}},function(){var a=this.prototype;Ext.apply(a,{nullResultSet:new Ext.data.ResultSet({total:0,count:0,records:[],success:true}),recordDataExtractorTemplate:new Ext.XTemplate(a.recordDataExtractorTemplate)})});Ext.define("Ext.data.reader.Json",{extend:"Ext.data.reader.Reader",alternateClassName:"Ext.data.JsonReader",alias:"reader.json",root:"",useSimpleAccessors:false,readRecords:function(a){if(a.metaData){this.onMetaChange(a.metaData)}this.jsonData=a;return this.callParent([a])},getResponseData:function(a){var d,b;try{d=Ext.decode(a.responseText);return this.readRecords(d)}catch(c){b=new Ext.data.ResultSet({total:0,count:0,records:[],success:false,message:c.message});this.fireEvent("exception",this,a,b);Ext.Logger.warn("Unable to parse the JSON returned by the server");return b}},buildExtractors:function(){var a=this;a.callParent(arguments);if(a.root){a.getRoot=a.createAccessor(a.root)}else{a.getRoot=function(b){return b}}},extractData:function(a){var e=this.record,d=[],c,b;if(e){c=a.length;if(!c&&Ext.isObject(a)){c=1;a=[a]}for(b=0;b<c;b++){d[b]=a[b][e]}}else{d=a}return this.callParent([d])},createAccessor:(function(){var a=/[\[\.]/;return function(c){if(Ext.isEmpty(c)){return Ext.emptyFn}if(Ext.isFunction(c)){return c}if(this.useSimpleAccessors!==true){var b=String(c).search(a);if(b>=0){return Ext.functionFactory("obj","return obj"+(b>0?".":"")+c)}}return function(d){return d[c]}}}()),createFieldAccessExpression:(function(){var a=/[\[\.]/;return function(i,d,c){var e=this,g=(i.mapping!==null),h=g?i.mapping:i.name,b,j;if(typeof h==="function"){b=d+".mapping("+c+", this)"}else{if(this.useSimpleAccessors===true||((j=String(h).search(a))<0)){if(!g||isNaN(h)){h='"'+h+'"'}b=c+"["+h+"]"}else{b=c+(j>0?".":"")+h}}return b}}())});Ext.define("Ext.data.writer.Writer",{alias:"writer.base",alternateClassName:["Ext.data.DataWriter","Ext.data.Writer"],writeAllFields:true,nameProperty:"name",isWriter:true,constructor:function(a){Ext.apply(this,a)},write:function(e){var c=e.operation,b=c.records||[],a=b.length,d=0,g=[];for(;d<a;d++){g.push(this.getRecordData(b[d],c))}return this.writeRecords(e,g)},getRecordData:function(g,d){var n=g.phantom===true,b=this.writeAllFields||n,c=this.nameProperty,h=g.fields,p=h.items,e={},l=g.clientIdProperty,k,a,j,o,m,i,q;if(b){q=p.length;for(i=0;i<q;i++){j=p[i];if(j.persist){a=j[c]||j.name;m=g.get(j.name);if(j.serialize){e[a]=j.serialize(m,g)}else{if(j.type===Ext.data.Types.DATE&&j.dateFormat){e[a]=Ext.Date.format(m,j.dateFormat)}else{e[a]=m}}}}}else{k=g.getChanges();for(o in k){if(k.hasOwnProperty(o)){j=h.get(o);if(j.persist){a=j[c]||j.name;m=g.get(j.name);if(j.serialize){e[a]=j.serialize(m,g)}else{if(j.type===Ext.data.Types.DATE&&j.dateFormat){e[a]=Ext.Date.format(m,j.dateFormat)}else{e[a]=m}}}}}}if(n){if(l&&d&&d.records.length>1){e[l]=g.internalId}}else{e[g.idProperty]=g.getId()}return e}});Ext.define("Ext.data.writer.Json",{extend:"Ext.data.writer.Writer",alternateClassName:"Ext.data.JsonWriter",alias:"writer.json",root:undefined,encode:false,allowSingle:true,writeRecords:function(b,c){var a=this.root;if(this.allowSingle&&c.length==1){c=c[0]}if(this.encode){if(a){b.params[a]=Ext.encode(c)}else{}}else{b.jsonData=b.jsonData||{};if(a){b.jsonData[a]=c}else{b.jsonData=c}}return b}});Ext.define("Ext.data.proxy.Server",{extend:"Ext.data.proxy.Proxy",alias:"proxy.server",alternateClassName:"Ext.data.ServerProxy",uses:["Ext.data.Request"],pageParam:"page",startParam:"start",limitParam:"limit",groupParam:"group",groupDirectionParam:"groupDir",sortParam:"sort",filterParam:"filter",directionParam:"dir",simpleSortMode:false,simpleGroupMode:false,noCache:true,cacheString:"_dc",timeout:30000,constructor:function(a){var b=this;a=a||{};b.callParent([a]);b.extraParams=a.extraParams||{};b.api=Ext.apply({},a.api||b.api);b.nocache=b.noCache},create:function(){return this.doRequest.apply(this,arguments)},read:function(){return this.doRequest.apply(this,arguments)},update:function(){return this.doRequest.apply(this,arguments)},destroy:function(){return this.doRequest.apply(this,arguments)},setExtraParam:function(a,b){this.extraParams[a]=b},buildRequest:function(a){var c=this,d=Ext.applyIf(a.params||{},c.extraParams||{}),b;d=Ext.applyIf(d,c.getParams(a));if(a.id!==undefined&&d.id===undefined){d.id=a.id}b=new Ext.data.Request({params:d,action:a.action,records:a.records,operation:a,url:a.url,proxy:c});b.url=c.buildUrl(b);a.request=b;return b},processResponse:function(h,a,c,b,g,i){var e=this,d,j;if(h===true){d=e.getReader();d.applyDefaults=a.action==="read";j=d.read(e.extractResponseData(b));if(j.success!==false){Ext.apply(a,{response:b,resultSet:j});a.commitRecords(j.records);a.setCompleted();a.setSuccessful()}else{a.setException(j.message);e.fireEvent("exception",this,b,a)}}else{e.setException(a,b);e.fireEvent("exception",this,b,a)}if(typeof g=="function"){g.call(i||e,a)}e.afterRequest(c,h)},setException:function(b,a){b.setException({status:a.status,statusText:a.statusText})},extractResponseData:function(a){return a},applyEncoding:function(a){return Ext.encode(a)},encodeSorters:function(d){var b=[],c=d.length,a=0;for(;a<c;a++){b[a]={property:d[a].property,direction:d[a].direction}}return this.applyEncoding(b)},encodeFilters:function(d){var b=[],c=d.length,a=0;for(;a<c;a++){b[a]={property:d[a].property,value:d[a].value}}return this.applyEncoding(b)},getParams:function(n){var u=this,t={},q=Ext.isDefined,r=n.groupers,a=n.sorters,l=n.filters,i=n.page,h=n.start,s=n.limit,j=u.simpleSortMode,d=u.simpleGroupMode,p=u.pageParam,g=u.startParam,b=u.limitParam,c=u.groupParam,k=u.groupDirectionParam,e=u.sortParam,o=u.filterParam,m=u.directionParam;if(p&&q(i)){t[p]=i}if(g&&q(h)){t[g]=h}if(b&&q(s)){t[b]=s}if(c&&r&&r.length>0){if(d){t[c]=r[0].property;t[k]=r[0].direction||"ASC"}else{t[c]=u.encodeSorters(r)}}if(e&&a&&a.length>0){if(j){t[e]=a[0].property;t[m]=a[0].direction}else{t[e]=u.encodeSorters(a)}}if(o&&l&&l.length>0){t[o]=u.encodeFilters(l)}return t},buildUrl:function(c){var b=this,a=b.getUrl(c);if(b.noCache){a=Ext.urlAppend(a,Ext.String.format("{0}={1}",b.cacheString,Ext.Date.now()))}return a},getUrl:function(a){return a.url||this.api[a.action]||this.url},doRequest:function(a,c,b){},afterRequest:Ext.emptyFn,onDestroy:function(){Ext.destroy(this.reader,this.writer)}});Ext.define("Ext.data.proxy.Ajax",{requires:["Ext.util.MixedCollection","Ext.Ajax"],extend:"Ext.data.proxy.Server",alias:"proxy.ajax",alternateClassName:["Ext.data.HttpProxy","Ext.data.AjaxProxy"],actionMethods:{create:"POST",read:"GET",update:"POST",destroy:"POST"},doRequest:function(a,e,b){var d=this.getWriter(),c=this.buildRequest(a,e,b);if(a.allowWrite()){c=d.write(c)}Ext.apply(c,{headers:this.headers,timeout:this.timeout,scope:this,callback:this.createRequestCallback(c,a,e,b),method:this.getMethod(c),disableCaching:false});Ext.Ajax.request(c);return c},getMethod:function(a){return this.actionMethods[a.action]},createRequestCallback:function(d,a,e,b){var c=this;return function(h,i,g){c.processResponse(i,a,d,g,e,b)}}},function(){Ext.data.HttpProxy=this});Ext.define("Ext.data.proxy.Client",{extend:"Ext.data.proxy.Proxy",alternateClassName:"Ext.data.ClientProxy",isSynchronous:true,clear:function(){}});Ext.define("Ext.data.proxy.Memory",{extend:"Ext.data.proxy.Client",alias:"proxy.memory",alternateClassName:"Ext.data.MemoryProxy",constructor:function(a){this.callParent([a]);this.setReader(this.reader)},updateOperation:function(b,g,d){var c=0,e=b.getRecords(),a=e.length;for(c;c<a;c++){e[c].commit()}b.setCompleted();b.setSuccessful();Ext.callback(g,d||this,[b])},create:function(){this.updateOperation.apply(this,arguments)},update:function(){this.updateOperation.apply(this,arguments)},destroy:function(){this.updateOperation.apply(this,arguments)},read:function(a,d,b){var c=this;a.resultSet=c.getReader().read(c.data);a.setCompleted();a.setSuccessful();Ext.callback(d,b||c,[a])},clear:Ext.emptyFn});Ext.define("Ext.util.LruCache",{extend:"Ext.util.HashMap",constructor:function(a){Ext.apply(this,a);this.callParent([a])},add:function(b,e){var d=this,a=d.findKey(e),c;if(a){d.unlinkEntry(c=d.map[a]);c.prev=d.last;c.next=null}else{c={prev:d.last,next:null,key:b,value:e}}if(d.last){d.last.next=c}else{d.first=c}d.last=c;d.callParent([b,c]);d.prune();return e},insertBefore:function(b,g,c){var e=this,a,d;if(c=this.map[this.findKey(c)]){a=e.findKey(g);if(a){e.unlinkEntry(d=e.map[a])}else{d={prev:c.prev,next:c,key:b,value:g}}if(c.prev){d.prev.next=d}else{e.first=d}d.next=c;c.prev=d;e.prune();return g}else{return e.add(b,g)}},get:function(a){var b=this.map[a];if(b){if(b.next){this.moveToEnd(b)}return b.value}},removeAtKey:function(a){this.unlinkEntry(this.map[a]);return this.callParent(arguments)},clear:function(a){this.first=this.last=null;return this.callParent(arguments)},unlinkEntry:function(a){if(a){if(a.next){a.next.prev=a.prev}else{this.last=a.prev}if(a.prev){a.prev.next=a.next}else{this.first=a.next}a.prev=a.next=null}},moveToEnd:function(a){this.unlinkEntry(a);if(a.prev=this.last){this.last.next=a}else{this.first=a}this.last=a},getArray:function(c){var a=[],b=this.first;while(b){a.push(c?b.key:b.value);b=b.next}return a},each:function(c,b,a){var g=this,e=a?g.last:g.first,d=g.length;b=b||g;while(e){if(c.call(b,e.key,e.value,d)===false){break}e=a?e.prev:e.next}return g},findKey:function(b){var a,c=this.map;for(a in c){if(c.hasOwnProperty(a)&&c[a].value===b){return a}}return undefined},prune:function(){var a=this,b=a.maxSize?(a.length-a.maxSize):0;if(b>0){for(;a.first&&b;b--){a.removeAtKey(a.first.key)}}}});Ext.define("Ext.data.Store",{extend:"Ext.data.AbstractStore",alias:"store.store",requires:["Ext.data.StoreManager","Ext.data.Model","Ext.data.proxy.Ajax","Ext.data.proxy.Memory","Ext.data.reader.Json","Ext.data.writer.Json","Ext.util.LruCache"],uses:["Ext.ModelManager","Ext.util.Grouper"],remoteSort:false,remoteFilter:false,remoteGroup:false,groupField:undefined,groupDir:"ASC",trailingBufferZone:25,leadingBufferZone:200,pageSize:undefined,currentPage:1,clearOnPageLoad:true,loading:false,sortOnFilter:true,buffered:false,purgePageCount:5,clearRemovedOnLoad:true,defaultPageSize:25,addRecordsOptions:{addRecords:true},statics:{recordIdFn:function(a){return a.internalId},recordIndexFn:function(a){return a.index}},onClassExtended:function(b,d,a){var c=d.model,e;if(typeof c=="string"){e=a.onBeforeCreated;a.onBeforeCreated=function(){var h=this,g=arguments;Ext.require(c,function(){e.apply(h,g)})}}},constructor:function(b){b=Ext.Object.merge({},b);var d=this,g=b.groupers||d.groupers,a=b.groupField||d.groupField,c,e;e=b.data||d.data;d.data=new Ext.util.MixedCollection(false,Ext.data.Store.recordIdFn);if(e){d.inlineData=e;delete b.data}if(!g&&a){g=[{property:a,direction:b.groupDir||d.groupDir}]}delete b.groupers;d.groupers=new Ext.util.MixedCollection();d.groupers.addAll(d.decodeGroupers(g));this.callParent([b]);if(d.buffered){d.pageMap=new d.PageMap({pageSize:d.pageSize,maxSize:d.purgePageCount,listeners:{clear:d.cancelAllPrefetches,scope:d}});d.pageRequests={};d.sortOnLoad=false;d.filterOnLoad=false}if(d.remoteGroup){d.remoteSort=true}if(d.groupers.items.length&&!d.remoteGroup){d.sort(d.groupers.items,"prepend",false)}c=d.proxy;e=d.inlineData;if(!d.buffered&&!d.pageSize){d.pageSize=d.defaultPageSize}if(e){if(c instanceof Ext.data.proxy.Memory){c.data=e;d.read()}else{d.add.apply(d,[e])}d.sort();delete d.inlineData}else{if(d.autoLoad){Ext.defer(d.load,10,d,[typeof d.autoLoad==="object"?d.autoLoad:undefined])}}},destroyStore:function(){this.callParent(arguments);if(this.pageMap){this.pageMap.clear()}},onBeforeSort:function(){var a=this.groupers;if(a.getCount()>0){this.sort(a.items,"prepend",false)}},decodeGroupers:function(e){if(!Ext.isArray(e)){if(e===undefined){e=[]}else{e=[e]}}var d=e.length,g=Ext.util.Grouper,b,c,a=[];for(c=0;c<d;c++){b=e[c];if(!(b instanceof g)){if(Ext.isString(b)){b={property:b}}b=Ext.apply({root:"data",direction:"ASC"},b);if(b.fn){b.sorterFn=b.fn}if(typeof b=="function"){b={sorterFn:b}}a.push(new g(b))}else{a.push(b)}}return a},group:function(e,g){var d=this,c=false,b,a;if(Ext.isArray(e)){a=e}else{if(Ext.isObject(e)){a=[e]}else{if(Ext.isString(e)){b=d.groupers.get(e);if(!b){b={property:e,direction:g};a=[b]}else{if(g===undefined){b.toggle()}else{b.setDirection(g)}}}}}if(a&&a.length){c=true;a=d.decodeGroupers(a);d.groupers.clear();d.groupers.addAll(a)}if(d.remoteGroup){if(d.buffered){d.pageMap.clear();d.loadPage(1,{groupChange:true})}else{d.load({scope:d,callback:d.fireGroupChange})}}else{d.sort(null,null,null,c);d.fireGroupChange()}},clearGrouping:function(){var d=this,e=d.groupers.items,c=e.length,a,b;for(b=0;b<c;b++){a=e[b];d.sorters.remove(a)}d.groupers.clear();if(d.remoteGroup){if(d.buffered){d.pageMap.clear();d.loadPage(1,{groupChange:true})}else{d.load({scope:d,callback:d.fireGroupChange})}}else{d.sort();d.fireGroupChange()}},isGrouped:function(){return this.groupers.getCount()>0},fireGroupChange:function(){this.fireEvent("groupchange",this,this.groupers)},getGroups:function(b){var d=this.data.items,a=d.length,c=[],k={},g,h,j,e;for(e=0;e<a;e++){g=d[e];h=this.getGroupString(g);j=k[h];if(j===undefined){j={name:h,children:[]};c.push(j);k[h]=j}j.children.push(g)}return b?k[b]:c},getGroupsForGrouper:function(g,b){var d=g.length,e=[],a,c,j,k,h;for(h=0;h<d;h++){j=g[h];c=b.getGroupString(j);if(c!==a){k={name:c,grouper:b,records:[]};e.push(k)}k.records.push(j);a=c}return e},getGroupsForGrouperIndex:function(c,j){var g=this,h=g.groupers,b=h.getAt(j),a=g.getGroupsForGrouper(c,b),e=a.length,d;if(j+1<h.length){for(d=0;d<e;d++){a[d].children=g.getGroupsForGrouperIndex(a[d].records,j+1)}}for(d=0;d<e;d++){a[d].depth=j}return a},getGroupData:function(a){var b=this;if(a!==false){b.sort()}return b.getGroupsForGrouperIndex(b.data.items,0)},getGroupString:function(a){var b=this.groupers.first();if(b){return a.get(b.property)}return""},insert:function(d,c){var h=this,g=false,e,b,a;c=[].concat(c);for(e=0,a=c.length;e<a;e++){b=h.createModel(c[e]);b.set(h.modelDefaults);c[e]=b;h.data.insert(d+e,b);b.join(h);g=g||b.phantom===true}if(h.snapshot){h.snapshot.addAll(c)}if(h.requireSort){h.suspendEvents();h.sort();h.resumeEvents()}h.fireEvent("add",h,c,d);h.fireEvent("datachanged",h);if(h.autoSync&&g&&!h.autoSyncSuspended){h.sync()}},add:function(b){if(!Ext.isArray(b)){b=Array.prototype.slice.apply(arguments)}else{b=b.slice(0)}var e=this,c=0,d=b.length,a,g=!e.remoteSort&&e.sorters&&e.sorters.items.length;if(g&&d===1){return[e.addSorted(e.createModel(b[0]))]}for(;c<d;c++){a=e.createModel(b[c]);b[c]=a}if(g){e.requireSort=true}e.insert(e.data.length,b);delete e.requireSort;return b},addSorted:function(a){var c=this,b=c.data.findInsertionIndex(a,c.generateComparator());c.insert(b,a);return a},createModel:function(a){if(!a.isModel){a=Ext.ModelManager.create(a,this.model)}return a},each:function(e,c){var g=this.data.items,b=g.length,a,h;for(h=0;h<b;h++){a=g[h];if(e.call(c||a,a,h,b)===false){break}}},remove:function(c,k){if(!Ext.isArray(c)){c=[c]}k=k===true;var h=this,j=false,d=0,a=c.length,b,g,e;for(;d<a;d++){e=c[d];g=h.data.indexOf(e);if(h.snapshot){h.snapshot.remove(e)}if(g>-1){b=e.phantom!==true;if(!k&&b){e.removedFrom=g;h.removed.push(e)}e.unjoin(h);h.data.remove(e);j=j||b;h.fireEvent("remove",h,e,g)}}h.fireEvent("datachanged",h);if(!k&&h.autoSync&&j&&!h.autoSyncSuspended){h.sync()}},removeAt:function(b){var a=this.getAt(b);if(a){this.remove(a)}},load:function(a){var b=this;a=a||{};if(typeof a=="function"){a={callback:a}}a.groupers=a.groupers||b.groupers.items;a.page=a.page||b.currentPage;a.start=(a.start!==undefined)?a.start:(a.page-1)*b.pageSize;a.limit=a.limit||b.pageSize;a.addRecords=a.addRecords||false;if(b.buffered){return b.loadToPrefetch(a)}return b.callParent([a])},reload:function(l){var g=this,h,b,e,k,d,a,j,c;if(!l){l={}}if(g.buffered){delete g.totalCount;a=function(){if(g.rangeCached(h,b)){g.loading=false;g.pageMap.un("pageAdded",a);c=g.pageMap.getRange(h,b);g.loadRecords(c,{start:h});g.fireEvent("load",g,c,true)}};j=Math.ceil((g.leadingBufferZone+g.trailingBufferZone)/2);h=l.start||g.getAt(0).index;b=h+(l.count||g.getCount())-1;e=g.getPageFromRecordIndex(Math.max(h-j,0));k=g.getPageFromRecordIndex(b+j);g.pageMap.clear(true);if(g.fireEvent("beforeload",g,l)!==false){g.loading=true;for(d=e;d<=k;d++){g.prefetchPage(d,l)}g.pageMap.on("pageAdded",a)}}else{return g.callParent(arguments)}},onProxyLoad:function(b){var d=this,c=b.getResultSet(),a=b.getRecords(),e=b.wasSuccessful();if(c){d.totalCount=c.total}if(e){d.loadRecords(a,b)}d.loading=false;if(d.hasListeners.load){d.fireEvent("load",d,a,e)}if(d.hasListeners.read){d.fireEvent("read",d,a,e)}Ext.callback(b.callback,b.scope||d,[a,b,e])},getNewRecords:function(){return this.data.filterBy(this.filterNew).items},getUpdatedRecords:function(){return this.data.filterBy(this.filterUpdated).items},filter:function(e,g){if(Ext.isString(e)){e={property:e,value:g}}var d=this,a=d.decodeFilters(e),b=0,h=d.sorters.length&&d.sortOnFilter&&!d.remoteSort,c=a.length;for(;b<c;b++){d.filters.replace(a[b])}if(d.remoteFilter){delete d.totalCount;if(d.buffered){d.pageMap.clear();d.loadPage(1)}else{d.currentPage=1;d.load()}}else{if(d.filters.getCount()){d.snapshot=d.snapshot||d.data.clone();d.data=d.data.filter(d.filters.items);if(h){d.sort()}else{d.fireEvent("datachanged",d);d.fireEvent("refresh",d)}}}},clearFilter:function(a){var b=this;b.filters.clear();if(b.remoteFilter){if(a){return}delete b.totalCount;if(b.buffered){b.pageMap.clear();b.loadPage(1)}else{b.currentPage=1;b.load()}}else{if(b.isFiltered()){b.data=b.snapshot.clone();delete b.snapshot;if(a!==true){b.fireEvent("datachanged",b);b.fireEvent("refresh",b)}}}},isFiltered:function(){var a=this.snapshot;return !!a&&a!==this.data},filterBy:function(b,a){var c=this;c.snapshot=c.snapshot||c.data.clone();c.data=c.queryBy(b,a||c);c.fireEvent("datachanged",c);c.fireEvent("refresh",c)},queryBy:function(b,a){var c=this,d=c.snapshot||c.data;return d.filterBy(b,a||c)},query:function(h,g,i,a,e){var d=this,b=d.createFilterFn(h,g,i,a,e),c=d.queryBy(b);if(!c){c=new Ext.util.MixedCollection()}return c},loadData:function(j,a){var h=this,c=h.model,g=j.length,e=[],d,b;for(d=0;d<g;d++){b=j[d];if(!(b.isModel)){b=Ext.ModelManager.create(b,c)}e.push(b)}h.loadRecords(e,a?h.addRecordsOptions:undefined)},loadRawData:function(e,b){var d=this,a=d.proxy.reader.read(e),c=a.records;if(a.success){d.totalCount=a.total;d.loadRecords(c,b?d.addRecordsOptions:undefined);d.fireEvent("load",d,c,true)}},loadRecords:function(b,c){var h=this,d=0,g=b.length,j,e,a=h.snapshot;if(c){j=c.start;e=c.addRecords}if(!e){delete h.snapshot;h.clearData(true)}else{if(a){a.addAll(b)}}h.data.addAll(b);if(j!==undefined){for(;d<g;d++){b[d].index=j+d;b[d].join(h)}}else{for(;d<g;d++){b[d].join(h)}}h.suspendEvents();if(h.filterOnLoad&&!h.remoteFilter){h.filter()}if(h.sortOnLoad&&!h.remoteSort){h.sort(undefined,undefined,undefined,true)}h.resumeEvents();h.fireEvent("datachanged",h);h.fireEvent("refresh",h)},loadPage:function(c,a){var b=this;b.currentPage=c;a=Ext.apply({page:c,start:(c-1)*b.pageSize,limit:b.pageSize,addRecords:!b.clearOnPageLoad},a);if(b.buffered){return b.loadToPrefetch(a)}b.read(a)},nextPage:function(a){this.loadPage(this.currentPage+1,a)},previousPage:function(a){this.loadPage(this.currentPage-1,a)},clearData:function(d){var c=this,a=c.data.items,b=a.length;while(b--){a[b].unjoin(c)}c.data.clear();if(d!==true||c.clearRemovedOnLoad){c.removed.length=0}},loadToPrefetch:function(l){var h=this,d,b,j=l.start,a=l.start+l.limit-1,e=l.start+(h.viewSize||l.limit)-1,g=h.getPageFromRecordIndex(Math.max(j-h.trailingBufferZone,0)),k=h.getPageFromRecordIndex(a+h.leadingBufferZone),c=function(){if(h.rangeCached(j,e)){h.loading=false;b=h.pageMap.getRange(j,e);h.pageMap.un("pageAdded",c);if(h.hasListeners.guaranteedrange){h.guaranteeRange(j,e,l.callback,l.scope)}else{h.loadRecords(b,{start:j})}h.fireEvent("load",h,b,true);if(l.groupChange){h.fireGroupChange()}}};if(h.fireEvent("beforeload",h,l)!==false){delete h.totalCount;h.loading=true;h.pageMap.on("pageAdded",c);h.on("prefetch",function(){for(d=g+1;d<=k;++d){h.prefetchPage(d,l)}},null,{single:true});h.prefetchPage(g,l)}},prefetch:function(c){var e=this,a=e.pageSize,d,b;if(a){if(e.lastPageSize&&a!=e.lastPageSize){Ext.error.raise("pageSize cannot be dynamically altered")}if(!e.pageMap.pageSize){e.pageMap.pageSize=a}}else{e.pageSize=e.pageMap.pageSize=a=c.limit}e.lastPageSize=a;if(!c.page){c.page=e.getPageFromRecordIndex(c.start);c.start=(c.page-1)*a;c.limit=Math.ceil(c.limit/a)*a}if(!e.pageRequests[c.page]){c=Ext.apply({action:"read",filters:e.filters.items,sorters:e.sorters.items,groupers:e.groupers.items,generation:e.pageMap.generation},c);b=new Ext.data.Operation(c);if(e.fireEvent("beforeprefetch",e,b)!==false){e.loading=true;d=e.proxy;e.pageRequests[c.page]=d.read(b,e.onProxyPrefetch,e);if(d.isSynchronous){delete e.pageRequests[c.page]}}}return e},cancelAllPrefetches:function(){var c=this,a=c.pageRequests,b,d;if(c.pageMap.events.pageadded){c.pageMap.events.pageadded.clearListeners()}for(d in a){if(a.hasOwnProperty(d)){b=a[d];delete a[d];delete b.callback}}},prefetchPage:function(e,b){var d=this,a=d.pageSize||d.defaultPageSize,g=(e-1)*d.pageSize,c=d.totalCount;if(c!==undefined&&d.getCount()===c){return}d.prefetch(Ext.applyIf({page:e,start:g,limit:a},b))},onProxyPrefetch:function(b){var d=this,c=b.getResultSet(),a=b.getRecords(),g=b.wasSuccessful(),e=b.page;if(b.generation===d.pageMap.generation){if(c){d.totalCount=c.total;d.fireEvent("totalcountchange",d.totalCount)}if(e!==undefined){delete d.pageRequests[e]}if(g){d.cachePage(a,b.page)}d.loading=false;d.fireEvent("prefetch",d,a,g,b);Ext.callback(b.callback,b.scope||d,[a,b,g])}},cachePage:function(a,c){var b=this;if(!Ext.isDefined(b.totalCount)){b.totalCount=a.length;b.fireEvent("totalcountchange",b.totalCount)}b.pageMap.addPage(c,a)},rangeCached:function(b,a){return this.pageMap&&this.pageMap.hasRange(b,a)},pageCached:function(a){return this.pageMap&&this.pageMap.hasPage(a)},rangeSatisfied:function(b,a){return this.rangeCached(b,a)},getPageFromRecordIndex:function(a){return Math.floor(a/this.pageSize)+1},onGuaranteedRange:function(d){var e=this,b=e.getTotalCount(),g=d.prefetchStart,a=((b-1)<d.prefetchEnd)?b-1:d.prefetchEnd,c;a=Math.max(0,a);c=e.pageMap.getRange(g,a);e.fireEvent("guaranteedrange",c,g,a);if(d.cb){d.cb.call(d.scope||e,c,g,a)}},prefetchRange:function(g,b){var d=this,c,a,e;if(!d.rangeCached(g,b)){c=d.getPageFromRecordIndex(g);a=d.getPageFromRecordIndex(b);d.pageMap.maxSize=d.purgePageCount?(a-c+1)+d.purgePageCount:0;for(e=c;e<=a;e++){if(!d.pageCached(e)){d.prefetchPage(e)}}}},guaranteeRange:function(i,c,a,g){c=(c>this.totalCount)?this.totalCount-1:c;var h=this,e=h.lastRequestStart,d={prefetchStart:i,prefetchEnd:c,cb:a,scope:g},b;h.lastRequestStart=i;if(h.rangeCached(i,c)){if(i<e){i=Math.max(i-h.leadingBufferZone,0);c=Math.min(c+h.trailingBufferZone,h.totalCount-1)}else{i=Math.max(Math.min(i-h.trailingBufferZone,h.totalCount-h.pageSize),0);c=Math.min(c+h.leadingBufferZone,h.totalCount-1)}if(!h.rangeCached(i,c)){h.prefetchRange(i,c)}h.onGuaranteedRange(d)}else{h.fireEvent("cachemiss",h,i,c);i=Math.min(Math.max(Math.floor(i-((h.leadingBufferZone+h.trailingBufferZone)/2)),0),h.totalCount-h.pageSize);c=Math.min(Math.max(Math.ceil(c+((h.leadingBufferZone+h.trailingBufferZone)/2)),0),h.totalCount-1);b=function(k,j){if(h.rangeCached(d.prefetchStart,d.prefetchEnd)){h.fireEvent("cachefilled",h,i,c);h.pageMap.un("pageAdded",b);h.onGuaranteedRange(d)}};h.pageMap.on("pageAdded",b);h.prefetchRange(d.prefetchStart,d.prefetchEnd);h.prefetchRange(i,c)}},sort:function(){var b=this,a=b.pageMap;if(b.buffered){if(b.remoteSort){a.clear();b.callParent(arguments)}else{b.callParent(arguments)}}else{b.callParent(arguments)}},doSort:function(b){var e=this,a,d,c;if(e.remoteSort){if(e.buffered){e.pageMap.clear();e.loadPage(1)}else{e.load()}}else{e.data.sortBy(b);if(!e.buffered){a=e.getRange();d=a.length;for(c=0;c<d;c++){a[c].index=c}}e.fireEvent("datachanged",e);e.fireEvent("refresh",e)}},find:function(e,d,h,g,a,c){var b=this.createFilterFn(e,d,g,a,c);return b?this.data.findIndexBy(b,null,h):-1},findRecord:function(){var b=this,a=b.find.apply(b,arguments);return a!==-1?b.getAt(a):null},createFilterFn:function(d,c,e,a,b){if(Ext.isEmpty(c)){return false}c=this.data.createValueMatcher(c,e,a,b);return function(g){return c.test(g.data[d])}},findExact:function(b,a,c){return this.data.findIndexBy(function(d){return d.isEqual(d.get(b),a)},this,c)},findBy:function(b,a,c){return this.data.findIndexBy(b,a,c)},collect:function(b,a,c){var d=this,e=(c===true&&d.snapshot)?d.snapshot:d.data;return e.collect(b,"data",a)},getCount:function(){return this.data.length||0},getTotalCount:function(){return this.totalCount||0},getAt:function(a){return this.data.getAt(a)},getRange:function(b,a){return this.data.getRange(b,a)},getById:function(a){return(this.snapshot||this.data).findBy(function(b){return b.getId()===a})},indexOf:function(a){return this.data.indexOf(a)},indexOfTotal:function(a){var b=a.index;if(b||b===0){return b}return this.indexOf(a)},indexOfId:function(a){return this.indexOf(this.getById(a))},removeAll:function(a){var b=this;b.clearData();if(b.snapshot){b.snapshot.clear()}if(b.pageMap){b.pageMap.clear()}if(a!==true){b.fireEvent("clear",b)}},first:function(a){var b=this;if(a&&b.isGrouped()){return b.aggregate(function(c){return c.length?c[0]:undefined},b,true)}else{return b.data.first()}},last:function(a){var b=this;if(a&&b.isGrouped()){return b.aggregate(function(d){var c=d.length;return c?d[c-1]:undefined},b,true)}else{return b.data.last()}},sum:function(c,a){var b=this;if(a&&b.isGrouped()){return b.aggregate(b.getSum,b,true,[c])}else{return b.getSum(b.data.items,c)}},getSum:function(b,e){var d=0,c=0,a=b.length;for(;c<a;++c){d+=b[c].get(e)}return d},count:function(a){var b=this;if(a&&b.isGrouped()){return b.aggregate(function(c){return c.length},b,true)}else{return b.getCount()}},min:function(c,a){var b=this;if(a&&b.isGrouped()){return b.aggregate(b.getMin,b,true,[c])}else{return b.getMin(b.data.items,c)}},getMin:function(b,g){var d=1,a=b.length,e,c;if(a>0){c=b[0].get(g)}for(;d<a;++d){e=b[d].get(g);if(e<c){c=e}}return c},max:function(c,a){var b=this;if(a&&b.isGrouped()){return b.aggregate(b.getMax,b,true,[c])}else{return b.getMax(b.data.items,c)}},getMax:function(c,g){var d=1,b=c.length,e,a;if(b>0){a=c[0].get(g)}for(;d<b;++d){e=c[d].get(g);if(e>a){a=e}}return a},average:function(c,a){var b=this;if(a&&b.isGrouped()){return b.aggregate(b.getAverage,b,true,[c])}else{return b.getAverage(b.data.items,c)}},getAverage:function(b,e){var c=0,a=b.length,d=0;if(b.length>0){for(;c<a;++c){d+=b[c].get(e)}return d/a}return 0},aggregate:function(h,k,e,g){g=g||[];if(e&&this.isGrouped()){var a=this.getGroups(),c=0,d=a.length,b={},j;for(;c<d;++c){j=a[c];b[j.name]=h.apply(k||this,[j.children].concat(g))}return b}else{return h.apply(k||this,[this.data.items].concat(g))}},commitChanges:function(){var c=this,d=c.getModifiedRecords(),a=d.length,b=0;for(;b<a;b++){d[b].commit()}c.removed.length=0},filterNewOnly:function(a){return a.phantom===true},getRejectRecords:function(){return Ext.Array.push(this.data.filterBy(this.filterNewOnly).items,this.getUpdatedRecords())},rejectChanges:function(){var c=this,d=c.getRejectRecords(),a=d.length,b=0,e;for(;b<a;b++){e=d[b];e.reject();if(e.phantom){c.remove(e)}}d=c.removed;a=d.length;for(b=0;b<a;b++){e=d[b];c.insert(e.removedFrom||0,e);e.reject()}c.removed.length=0}},function(){Ext.regStore("ext-empty-store",{fields:[],proxy:"memory"});this.prototype.PageMap=new Ext.Class({extend:"Ext.util.LruCache",clear:function(a){this.generation=(this.generation||0)+1;this.callParent(arguments)},getPageFromRecordIndex:this.prototype.getPageFromRecordIndex,addPage:function(b,a){this.add(b,a);this.fireEvent("pageAdded",b,a)},getPage:function(a){return this.get(a)},hasRange:function(d,b){var c=this.getPageFromRecordIndex(d),a=this.getPageFromRecordIndex(b);for(;c<=a;c++){if(!this.hasPage(c)){return false}}return true},hasPage:function(a){return !!this.get(a)},getRange:function(a,b){if(!this.hasRange(a,b)){Ext.Error.raise("PageMap asked for range which it does not have")}var k=this,g=k.getPageFromRecordIndex(a),n=k.getPageFromRecordIndex(b),c=(g-1)*k.pageSize,o=(n*k.pageSize)-1,j=g,p=[],m,h,l,d=0,e;for(;j<=n;j++){if(j==g){m=a-c;l=true}else{m=0;l=false}if(j==n){h=k.pageSize-(o-b);l=true}if(l){Ext.Array.push(p,Ext.Array.slice(k.getPage(j),m,h))}else{Ext.Array.push(p,k.getPage(j))}}for(e=p.length;d<e;d++){p[d].index=a++}return p}})});Ext.define("Ext.data.reader.Array",{extend:"Ext.data.reader.Json",alternateClassName:"Ext.data.ArrayReader",alias:"reader.array",totalProperty:undefined,successProperty:undefined,createFieldAccessExpression:function(e,c,b){var d=(e.mapping==null)?e.originalIndex:e.mapping,a;if(typeof d==="function"){a=c+".mapping("+b+", this)"}else{if(isNaN(d)){d='"'+d+'"'}a=b+"["+d+"]"}return a}});Ext.define("Ext.data.ArrayStore",{extend:"Ext.data.Store",alias:"store.array",requires:["Ext.data.proxy.Memory","Ext.data.reader.Array"],constructor:function(a){a=Ext.apply({proxy:{type:"memory",reader:"array"}},a);this.callParent([a])},loadData:function(e,a){if(this.expandData===true){var d=[],b=0,c=e.length;for(;b<c;b++){d[d.length]=[e[b]]}e=d}this.callParent([e,a])}},function(){Ext.data.SimpleStore=Ext.data.ArrayStore});Ext.define("Ext.data.Batch",{mixins:{observable:"Ext.util.Observable"},autoStart:false,pauseOnException:false,current:-1,total:0,isRunning:false,isComplete:false,hasException:false,constructor:function(a){var b=this;b.mixins.observable.constructor.call(b,a);b.operations=[];b.exceptions=[]},add:function(a){this.total++;a.setBatch(this);this.operations.push(a);return this},start:function(a){var b=this;if(b.isRunning){return b}b.exceptions.length=0;b.hasException=false;b.isRunning=true;return b.runOperation(Ext.isDefined(a)?a:b.current+1)},retry:function(){return this.start(this.current)},runNextOperation:function(){return this.runOperation(this.current+1)},pause:function(){this.isRunning=false;return this},runOperation:function(d){var e=this,c=e.operations,b=c[d],a;if(b===undefined){e.isRunning=false;e.isComplete=true;e.fireEvent("complete",e,c[c.length-1])}else{e.current=d;a=function(g){var h=g.hasException();if(h){e.hasException=true;e.exceptions.push(g);e.fireEvent("exception",e,g)}if(h&&e.pauseOnException){e.pause()}else{g.setCompleted();e.fireEvent("operationcomplete",e,g);e.runNextOperation()}};b.setStarted();e.proxy[b.action](b,a,e)}return e}});Ext.define("Ext.data.BufferStore",{extend:"Ext.data.Store",alias:"store.buffer",sortOnLoad:false,filterOnLoad:false,constructor:function(){Ext.Error.raise("The BufferStore class has been deprecated. Instead, specify the buffered config option on Ext.data.Store")}});Ext.define("Ext.direct.Manager",{singleton:true,mixins:{observable:"Ext.util.Observable"},requires:["Ext.util.MixedCollection"],exceptions:{TRANSPORT:"xhr",PARSE:"parse",LOGIN:"login",SERVER:"exception"},constructor:function(){var a=this;a.addEvents("event","exception");a.transactions=new Ext.util.MixedCollection();a.providers=new Ext.util.MixedCollection();a.mixins.observable.constructor.call(a)},addProvider:function(e){var d=this,b=arguments,c=0,a;if(b.length>1){for(a=b.length;c<a;++c){d.addProvider(b[c])}return}if(!e.isProvider){e=Ext.create("direct."+e.type+"provider",e)}d.providers.add(e);e.on("data",d.onProviderData,d);if(!e.isConnected()){e.connect()}return e},getProvider:function(a){return a.isProvider?a:this.providers.get(a)},removeProvider:function(c){var b=this,a=b.providers;c=c.isProvider?c:a.get(c);if(c){c.un("data",b.onProviderData,b);a.remove(c);return c}return null},addTransaction:function(a){this.transactions.add(a);return a},removeTransaction:function(a){a=this.getTransaction(a);this.transactions.remove(a);return a},getTransaction:function(a){return Ext.isObject(a)?a:this.transactions.get(a)},onProviderData:function(e,d){var c=this,b=0,a;if(Ext.isArray(d)){for(a=d.length;b<a;++b){c.onProviderData(e,d[b])}return}if(d.name&&d.name!="event"&&d.name!="exception"){c.fireEvent(d.name,d)}else{if(d.status===false){c.fireEvent("exception",d)}}c.fireEvent("event",d,e)},parseMethod:function(c){if(Ext.isString(c)){var e=c.split("."),b=0,a=e.length,d=window;while(d&&b<a){d=d[e[b]];++b}c=Ext.isFunction(d)?d:null}return c||null}},function(){Ext.Direct=Ext.direct.Manager});Ext.define("Ext.data.proxy.Direct",{extend:"Ext.data.proxy.Server",alternateClassName:"Ext.data.DirectProxy",alias:"proxy.direct",requires:["Ext.direct.Manager"],paramOrder:undefined,paramsAsHash:true,directFn:undefined,paramOrderRe:/[\s,|]/,constructor:function(b){var e=this,a,d,c;e.callParent(arguments);a=e.paramOrder;if(Ext.isString(a)){e.paramOrder=a.split(e.paramOrderRe)}d=e.directFn;if(d){e.directFn=Ext.direct.Manager.parseMethod(d)}c=e.api;for(d in c){if(c.hasOwnProperty(d)){c[d]=Ext.direct.Manager.parseMethod(c[d])}}},doRequest:function(d,j,k){var h=this,b=h.getWriter(),e=h.buildRequest(d,j,k),i=h.api[e.action]||h.directFn,c=e.params,g=[],a;if(d.allowWrite()){e=b.write(e)}if(d.action=="read"){a=i.directCfg.method;g=a.getArgs(c,h.paramOrder,h.paramsAsHash)}else{g.push(e.jsonData)}Ext.apply(e,{args:g,directFn:i});g.push(h.createRequestCallback(e,d,j,k),h);i.apply(window,g)},applyEncoding:function(a){return a},createRequestCallback:function(d,a,e,b){var c=this;return function(h,g){c.processResponse(g.status,a,d,g,e,b)}},extractResponseData:function(a){return Ext.isDefined(a.result)?a.result:a.data},setException:function(b,a){b.setException(a.message)},buildUrl:function(){return""}});Ext.define("Ext.data.DirectStore",{extend:"Ext.data.Store",alias:"store.direct",requires:["Ext.data.proxy.Direct"],constructor:function(a){a=Ext.apply({},a);if(!a.proxy){var b={type:"direct",reader:{type:"json"}};Ext.copyTo(b,a,"paramOrder,paramsAsHash,directFn,api,simpleSortMode");Ext.copyTo(b.reader,a,"totalProperty,root,idProperty");a.proxy=b}this.callParent([a])}});Ext.define("Ext.data.JsonP",{singleton:true,requestCount:0,requests:{},timeout:30000,disableCaching:true,disableCachingParam:"_dc",callbackKey:"callback",request:function(n){n=Ext.apply({},n);var j=this,d=Ext.isDefined(n.disableCaching)?n.disableCaching:j.disableCaching,h=n.disableCachingParam||j.disableCachingParam,c=++j.requestCount,l=n.callbackName||"callback"+c,i=n.callbackKey||j.callbackKey,m=Ext.isDefined(n.timeout)?n.timeout:j.timeout,e=Ext.apply({},n.params),b=n.url,a=Ext.name,g,k;e[i]=a+".data.JsonP."+l;if(d){e[h]=new Date().getTime()}k=j.createScript(b,e,n);j.requests[c]=g={url:b,params:e,script:k,id:c,scope:n.scope,success:n.success,failure:n.failure,callback:n.callback,callbackKey:i,callbackName:l};if(m>0){g.timeout=setTimeout(Ext.bind(j.handleTimeout,j,[g]),m)}j.setupErrorHandling(g);j[l]=Ext.bind(j.handleResponse,j,[g],true);j.loadScript(g);return g},abort:function(c){var b=this,d=b.requests,a;if(c){if(!c.id){c=d[c]}b.handleAbort(c)}else{for(a in d){if(d.hasOwnProperty(a)){b.abort(d[a])}}}},setupErrorHandling:function(a){a.script.onerror=Ext.bind(this.handleError,this,[a])},handleAbort:function(a){a.errorType="abort";this.handleResponse(null,a)},handleError:function(a){a.errorType="error";this.handleResponse(null,a)},cleanupErrorHandling:function(a){a.script.onerror=null},handleTimeout:function(a){a.errorType="timeout";this.handleResponse(null,a)},handleResponse:function(a,b){var c=true;if(b.timeout){clearTimeout(b.timeout)}delete this[b.callbackName];delete this.requests[b.id];this.cleanupErrorHandling(b);Ext.fly(b.script).remove();if(b.errorType){c=false;Ext.callback(b.failure,b.scope,[b.errorType])}else{Ext.callback(b.success,b.scope,[a])}Ext.callback(b.callback,b.scope,[c,a,b.errorType])},createScript:function(c,d,b){var a=document.createElement("script");a.setAttribute("src",Ext.urlAppend(c,Ext.Object.toQueryString(d)));a.setAttribute("async",true);a.setAttribute("type","text/javascript");return a},loadScript:function(a){Ext.getHead().appendChild(a.script)}});Ext.define("Ext.data.proxy.JsonP",{extend:"Ext.data.proxy.Server",alternateClassName:"Ext.data.ScriptTagProxy",alias:["proxy.jsonp","proxy.scripttag"],requires:["Ext.data.JsonP"],defaultWriterType:"base",callbackKey:"callback",recordParam:"records",autoAppendParams:true,constructor:function(){this.addEvents("exception");this.callParent(arguments)},doRequest:function(a,h,b){var d=this,e=d.getWriter(),c=d.buildRequest(a),g=c.params;if(a.allowWrite()){c=e.write(c)}Ext.apply(c,{callbackKey:d.callbackKey,timeout:d.timeout,scope:d,disableCaching:false,callback:d.createRequestCallback(c,a,h,b)});if(d.autoAppendParams){c.params={}}c.jsonp=Ext.data.JsonP.request(c);c.params=g;a.setStarted();d.lastRequest=c;return c},createRequestCallback:function(d,a,e,b){var c=this;return function(i,g,h){delete c.lastRequest;c.processResponse(i,a,d,g,e,b)}},setException:function(b,a){b.setException(b.request.jsonp.errorType)},buildUrl:function(h){var g=this,b=g.callParent(arguments),j=Ext.apply({},h.params),e=j.filters,a,d,c;delete j.filters;if(g.autoAppendParams){b=Ext.urlAppend(b,Ext.Object.toQueryString(j))}if(e&&e.length){for(c=0;c<e.length;c++){d=e[c];if(d.value){b=Ext.urlAppend(b,d.property+"="+d.value)}}}a=h.records;if(Ext.isArray(a)&&a.length>0){b=Ext.urlAppend(b,Ext.String.format("{0}={1}",g.recordParam,g.encodeRecords(a)))}return b},destroy:function(){this.abort();this.callParent(arguments)},abort:function(){var a=this.lastRequest;if(a){Ext.data.JsonP.abort(a.jsonp)}},encodeRecords:function(b){var d="",c=0,a=b.length;for(;c<a;c++){d+=Ext.Object.toQueryString(b[c].getData())}return d}});Ext.define("Ext.data.JsonPStore",{extend:"Ext.data.Store",alias:"store.jsonp",requires:["Ext.data.proxy.JsonP","Ext.data.reader.Json"],constructor:function(a){a=Ext.apply({proxy:{type:"jsonp",reader:"json"}},a);this.callParent([a])}});Ext.define("Ext.data.JsonStore",{extend:"Ext.data.Store",alias:"store.json",requires:["Ext.data.proxy.Ajax","Ext.data.reader.Json","Ext.data.writer.Json"],constructor:function(a){a=Ext.apply({proxy:{type:"ajax",reader:"json",writer:"json"}},a);this.callParent([a])}});Ext.define("Ext.data.NodeInterface",{requires:["Ext.data.Field"],statics:{decorate:function(b){var a,c;if(typeof b=="string"){b=Ext.ModelManager.getModel(b)}else{if(b.isModel){b=Ext.ModelManager.getModel(b.modelName)}}if(b.prototype.isNode){return}a=b.prototype.idProperty;idField=b.prototype.fields.get(a);c=b.prototype.fields.get(a).type.type;b.override(this.getPrototypeBody());this.applyFields(b,[{name:"parentId",type:c,defaultValue:null,useNull:idField.useNull},{name:"index",type:"int",defaultValue:null,persist:false},{name:"depth",type:"int",defaultValue:0,persist:false},{name:"expanded",type:"bool",defaultValue:false,persist:false},{name:"expandable",type:"bool",defaultValue:true,persist:false},{name:"checked",type:"auto",defaultValue:null,persist:false},{name:"leaf",type:"bool",defaultValue:false},{name:"cls",type:"string",defaultValue:null,persist:false},{name:"iconCls",type:"string",defaultValue:null,persist:false},{name:"icon",type:"string",defaultValue:null,persist:false},{name:"root",type:"boolean",defaultValue:false,persist:false},{name:"isLast",type:"boolean",defaultValue:false,persist:false},{name:"isFirst",type:"boolean",defaultValue:false,persist:false},{name:"allowDrop",type:"boolean",defaultValue:true,persist:false},{name:"allowDrag",type:"boolean",defaultValue:true,persist:false},{name:"loaded",type:"boolean",defaultValue:false,persist:false},{name:"loading",type:"boolean",defaultValue:false,persist:false},{name:"href",type:"string",defaultValue:null,persist:false},{name:"hrefTarget",type:"string",defaultValue:null,persist:false},{name:"qtip",type:"string",defaultValue:null,persist:false},{name:"qtitle",type:"string",defaultValue:null,persist:false},{name:"children",type:"auto",defaultValue:null,persist:false}])},applyFields:function(c,b){var h=c.prototype,a=h.fields,g=a.keys,e=b.length,j,d;for(d=0;d<e;d++){j=b[d];if(!Ext.Array.contains(g,j.name)){a.add(new Ext.data.Field(j))}}},getPrototypeBody:function(){return{isNode:true,constructor:function(){var a=this;this.callParent(arguments);Ext.applyIf(a,{firstChild:null,lastChild:null,parentNode:null,previousSibling:null,nextSibling:null,childNodes:[]});a.enableBubble(["append","remove","move","insert","beforeappend","beforeremove","beforemove","beforeinsert","expand","collapse","beforeexpand","beforecollapse","sort"]);return a},createNode:function(a){if(Ext.isObject(a)&&!a.isModel){a=Ext.ModelManager.create(a,this.modelName)}if(!a.childNodes){Ext.applyIf(a,{firstChild:null,lastChild:null,parentNode:null,previousSibling:null,nextSibling:null,childNodes:[]})}return a},isLeaf:function(){return this.get("leaf")===true},setFirstChild:function(a){this.firstChild=a},setLastChild:function(a){this.lastChild=a},updateInfo:function(g){var m=this,b=m.isRoot(),k=m.parentNode,d=(!k||b?true:k.firstChild===m),j=(!k||b?true:k.lastChild===m),h=0,n=m,a=m.childNodes,l=a.length,e=0,c=m.phantom;while(n.parentNode){++h;n=n.parentNode}m.beginEdit();m.set({isFirst:d,isLast:j,depth:h,index:k?k.indexOf(m):0,parentId:k?k.getId():null});m.endEdit(true);if(g){m.commit();m.phantom=c}for(e=0;e<l;e++){a[e].updateInfo(g)}},isLast:function(){return this.get("isLast")},isFirst:function(){return this.get("isFirst")},hasChildNodes:function(){return !this.isLeaf()&&this.childNodes.length>0},isExpandable:function(){var a=this;if(a.get("expandable")){return !(a.isLeaf()||(a.isLoaded()&&!a.hasChildNodes()))}return false},triggerUIUpdate:function(){this.afterEdit([])},appendChild:function(b,k,c){var h=this,d,g,e,j,a;if(Ext.isArray(b)){h.callStore("suspendAutoSync");for(d=0,g=b.length-1;d<g;d++){h.appendChild(b[d])}h.callStore("resumeAutoSync");h.appendChild(b[g])}else{b=h.createNode(b);if(k!==true&&(!h.hasListeners.beforeappend||h.fireEvent("beforeappend",h,b)===false)){return false}e=h.childNodes.length;j=b.parentNode;if(j){if(k!==true&&(!h.hasListeners.beforeremove||b.fireEvent("beforemove",b,j,h,e)===false)){return false}j.removeChild(b,false,false,true)}e=h.childNodes.length;if(e===0){h.setFirstChild(b)}h.childNodes.push(b);b.parentNode=h;b.nextSibling=null;h.setLastChild(b);a=h.childNodes[e-1];if(a){b.previousSibling=a;a.nextSibling=b;a.updateInfo(c)}else{b.previousSibling=null}b.updateInfo(c);if(!h.isLoaded()){h.set("loaded",true)}else{if(h.childNodes.length===1){h.triggerUIUpdate()}}if(!b.isLeaf()&&b.phantom){b.set("loaded",true)}if(k!==true){h.fireEvent("append",h,b,e);if(j){b.fireEvent("move",b,j,h,e)}}return b}},getBubbleTarget:function(){return this.parentNode},removeChild:function(j,e,g,b){var h=this,c=h.indexOf(j),d,a;if(c==-1||(g!==true&&(!h.hasListeners.beforeremove||h.fireEvent("beforeremove",h,j,!!b)===false))){return false}Ext.Array.erase(h.childNodes,c,1);if(h.firstChild==j){h.setFirstChild(j.nextSibling)}if(h.lastChild==j){h.setLastChild(j.previousSibling)}if(j.previousSibling){j.previousSibling.nextSibling=j.nextSibling}if(j.nextSibling){j.nextSibling.previousSibling=j.previousSibling}for(d=c>0?c-1:0,a=h.childNodes.length;d<a;d++){h.childNodes[d].updateInfo()}if(!h.childNodes.length){h.triggerUIUpdate()}if(g!==true){if(h.hasListeners.remove){h.fireEvent("remove",h,j,!!b)}}if(e){j.destroy(true)}else{j.clear()}return j},copy:function(d,c){var g=this,b=g.callOverridden(arguments),a=g.childNodes?g.childNodes.length:0,e;if(c){for(e=0;e<a;e++){b.appendChild(g.childNodes[e].copy(true))}}return b},clear:function(a){var b=this;b.parentNode=b.previousSibling=b.nextSibling=null;if(a){b.firstChild=b.lastChild=null}},destroy:function(b){var d=this,c=d.destroyOptions,a=d.childNodes,e=a.length,g;if(b===true){d.clear(true);for(g=0;g<e;g++){a[g].destroy(true)}d.childNodes=null;delete d.destroyOptions;d.callOverridden([c])}else{d.destroyOptions=b;d.remove(true)}},insertBefore:function(b,g,l){var h=this,e=h.indexOf(g),j=b.parentNode,k=e,c,a,d;if(!g){return h.appendChild(b)}if(b==g){return false}b=h.createNode(b);if(l!==true&&(!h.hasListeners.beforeinsert||h.fireEvent("beforeinsert",h,b,g)===false)){return false}if(j==h&&h.indexOf(b)<e){k--}if(j){if(l!==true&&(!h.hasListeners.beforeremove||b.fireEvent("beforemove",b,j,h,e,g)===false)){return false}j.removeChild(b,false,false,true)}if(k===0){h.setFirstChild(b)}Ext.Array.splice(h.childNodes,k,0,b);b.parentNode=h;b.nextSibling=g;g.previousSibling=b;a=h.childNodes[k-1];if(a){b.previousSibling=a;a.nextSibling=b}else{b.previousSibling=null}for(d=k>0?k-1:0,c=h.childNodes.length;d<c;d++){h.childNodes[d].updateInfo()}if(!h.isLoaded()){h.set("loaded",true)}else{if(h.childNodes.length===1){h.triggerUIUpdate()}}if(!b.isLeaf()&&b.phantom){b.set("loaded",true)}if(l!==true){if(h.hasListeners.insert){h.fireEvent("insert",h,b,g)}if(j&&h.hasListeners.move){b.fireEvent("move",b,j,h,k,g)}}return b},insertChild:function(a,c){var b=this.childNodes[a];if(b){return this.insertBefore(c,b)}else{return this.appendChild(c)}},remove:function(b,c){var a=this.parentNode;if(a){a.removeChild(this,b,c)}return this},removeAll:function(a,b){var d=this.childNodes,c;while((c=d[0])){this.removeChild(c,a,b)}return this},getChildAt:function(a){return this.childNodes[a]},replaceChild:function(a,d,c){var b=d?d.nextSibling:null;this.removeChild(d,false,c);this.insertBefore(a,b,c);return d},indexOf:function(a){return Ext.Array.indexOf(this.childNodes,a)},indexOfId:function(d){var c=this.childNodes,a=c.length,b=0;for(;b<a;++b){if(c[b].getId()===d){return b}}return -1},getPath:function(d,c){d=d||this.idProperty;c=c||"/";var b=[this.get(d)],a=this.parentNode;while(a){b.unshift(a.get(d));a=a.parentNode}return c+b.join(c)},getDepth:function(){return this.get("depth")},bubble:function(c,b,a){var d=this;while(d){if(c.apply(b||d,a||[d])===false){break}d=d.parentNode}},cascade:function(){if(Ext.isDefined(Ext.global.console)){Ext.global.console.warn("Ext.data.Node: cascade has been deprecated. Please use cascadeBy instead.")}return this.cascadeBy.apply(this,arguments)},cascadeBy:function(d,c,a){if(d.apply(c||this,a||[this])!==false){var g=this.childNodes,e=g.length,b;for(b=0;b<e;b++){g[b].cascadeBy(d,c,a)}}},eachChild:function(d,c,a){var g=this.childNodes,e=g.length,b;for(b=0;b<e;b++){if(d.apply(c||this,a||[g[b]])===false){break}}},findChild:function(b,c,a){return this.findChildBy(function(){return this.get(b)==c},null,a)},findChildBy:function(h,g,b){var e=this.childNodes,a=e.length,d=0,j,c;for(;d<a;d++){j=e[d];if(h.call(g||j,j)===true){return j}else{if(b){c=j.findChildBy(h,g,b);if(c!==null){return c}}}}return null},contains:function(a){return a.isAncestor(this)},isAncestor:function(a){var b=this.parentNode;while(b){if(b==a){return true}b=b.parentNode}return false},sort:function(g,b,a){var d=this.childNodes,e=d.length,c,h;if(e>0){Ext.Array.sort(d,g);for(c=0;c<e;c++){h=d[c];h.previousSibling=d[c-1];h.nextSibling=d[c+1];if(c===0){this.setFirstChild(h)}if(c==e-1){this.setLastChild(h)}h.updateInfo();if(b&&!h.isLeaf()){h.sort(g,true,true)}}if(a!==true){this.fireEvent("sort",this,d)}}},isExpanded:function(){return this.get("expanded")},isLoaded:function(){return this.get("loaded")},isLoading:function(){return this.get("loading")},isRoot:function(){return !this.parentNode},isVisible:function(){var a=this.parentNode;while(a){if(!a.isExpanded()){return false}a=a.parentNode}return true},expand:function(a,d,b){var c=this;if(!c.isLeaf()){if(c.isLoading()){c.on("expand",function(){c.expand(a,d,b)},c,{single:true})}else{if(!c.isExpanded()){c.fireEvent("beforeexpand",c,function(){c.set("expanded",true);if(c.hasListeners.expand){c.fireEvent("expand",c,c.childNodes,false)}if(a){c.expandChildren(true,d,b)}else{Ext.callback(d,b||c,[c.childNodes])}},c)}else{if(a){c.expandChildren(true,d,b)}else{Ext.callback(d,b||c,[c.childNodes])}}}}else{Ext.callback(d,b||c)}},expandChildren:function(d,j,k){var h=this,e=0,a=h.childNodes,g=a.length,c,b=0;for(;e<g;++e){c=a[e];if(!c.isLeaf()){b++;a[e].expand(d,function(){b--;if(j&&!b){Ext.callback(j,k||h,[h.childNodes])}})}}if(!b&&j){Ext.callback(j,k||h,[h.childNodes])}},collapse:function(a,d,b){var c=this;if(!c.isLeaf()){if(!c.collapsing&&c.isExpanded()){c.fireEvent("beforecollapse",c,function(){c.set("expanded",false);if(c.hasListeners.collapse){c.fireEvent("collapse",c,c.childNodes,false)}if(a){c.collapseChildren(true,d,b)}else{Ext.callback(d,b||c,[c.childNodes])}},c)}else{if(a){c.collapseChildren(true,d,b)}else{Ext.callback(d,b||c,[c.childNodes])}}}else{Ext.callback(d,b||c,[c.childNodes])}},collapseChildren:function(d,j,k){var h=this,e=0,b=h.childNodes,g=b.length,c,a=0;for(;e<g;++e){c=b[e];if(!c.isLeaf()){a++;b[e].collapse(d,function(){a--;if(j&&!a){Ext.callback(j,k||h,[h.childNodes])}})}}if(!a&&j){Ext.callback(j,k||h,[h.childNodes])}}}}}});Ext.define("Ext.data.NodeStore",{extend:"Ext.data.Store",alias:"store.node",requires:["Ext.data.NodeInterface"],node:null,recursive:false,rootVisible:false,constructor:function(a){var c=this,b;a=a||{};Ext.apply(c,a);a.proxy={type:"proxy"};c.callParent([a]);b=c.node;if(b){c.node=null;c.setNode(b)}},setNode:function(b){var a=this;if(a.node&&a.node!=b){a.mun(a.node,{expand:a.onNodeExpand,collapse:a.onNodeCollapse,append:a.onNodeAppend,insert:a.onNodeInsert,remove:a.onNodeRemove,sort:a.onNodeSort,scope:a});a.node=null}if(b){Ext.data.NodeInterface.decorate(b.self);a.removeAll();if(a.rootVisible){a.add(b)}else{if(!b.isExpanded()&&a.treeStore.autoLoad!==false){b.expand()}}a.mon(b,{expand:a.onNodeExpand,collapse:a.onNodeCollapse,append:a.onNodeAppend,insert:a.onNodeInsert,remove:a.onNodeRemove,sort:a.onNodeSort,scope:a});a.node=b;if(b.isExpanded()&&b.isLoaded()){a.onNodeExpand(b,b.childNodes,true)}}},onNodeSort:function(b,c){var a=this;if((a.indexOf(b)!==-1||(b===a.node&&!a.rootVisible)&&b.isExpanded())){a.onNodeCollapse(b,c,true);a.onNodeExpand(b,c,true)}},onNodeExpand:function(g,d,c){var j=this,a=j.indexOf(g)+1,h=d?d.length:0,e,b;if(!j.recursive&&g!==j.node){return}if(g!==this.node&&!j.isVisible(g)){return}if(!c&&j.fireEvent("beforeexpand",g,d,a)===false){return}if(h){j.insert(a,d);for(e=0;e<h;e++){b=d[e];if(b.isExpanded()){if(b.isLoaded()){j.onNodeExpand(b,b.childNodes,true)}else{b.set("expanded",false);b.expand()}}}}if(!c){j.fireEvent("expand",g,d)}},onNodeCollapse:function(g,c,b){var j=this,h=c.length,e=j.indexOf(g)+1,d,a;if(!j.recursive&&g!==j.node){return}if(!b&&j.fireEvent("beforecollapse",g,c,e)===false){return}for(d=0;d<h;d++){a=c[d];j.remove(a);if(a.isExpanded()){j.onNodeCollapse(a,a.childNodes,true)}}if(!b){j.fireEvent("collapse",g,c,e)}},onNodeAppend:function(d,g,b){var e=this,a,c;if(e.isVisible(g)){if(b===0){a=d}else{c=g.previousSibling;while(c.isExpanded()&&c.lastChild){c=c.lastChild}a=c}e.insert(e.indexOf(a)+1,g);if(!g.isLeaf()&&g.isExpanded()){if(g.isLoaded()){e.onNodeExpand(g,g.childNodes,true)}else{g.set("expanded",false);g.expand()}}}},onNodeInsert:function(c,e,a){var d=this,b=this.indexOf(a);if(b!=-1&&d.isVisible(e)){d.insert(b,e);if(!e.isLeaf()&&e.isExpanded()){if(e.isLoaded()){d.onNodeExpand(e,e.childNodes,true)}else{e.set("expanded",false);e.expand()}}}},onNodeRemove:function(b,d,a){var c=this;if(c.indexOf(d)!=-1){if(!d.isLeaf()&&d.isExpanded()){c.onNodeCollapse(d,d.childNodes,true)}c.remove(d)}},isVisible:function(b){var a=b.parentNode;while(a){if(a===this.node&&!this.rootVisible&&a.isExpanded()){return true}if(this.indexOf(a)===-1||!a.isExpanded()){return false}a=a.parentNode}return true}});Ext.define("Ext.data.Request",{action:undefined,params:undefined,method:"GET",url:undefined,constructor:function(a){Ext.apply(this,a)}});Ext.define("Ext.data.SequentialIdGenerator",{extend:"Ext.data.IdGenerator",alias:"idgen.sequential",constructor:function(){var a=this;a.callParent(arguments);a.parts=[a.prefix,""]},prefix:"",seed:1,generate:function(){var a=this,b=a.parts;b[1]=a.seed++;return b.join("")}});Ext.define("Ext.data.Tree",{alias:"data.tree",mixins:{observable:"Ext.util.Observable"},root:null,constructor:function(a){var b=this;b.mixins.observable.constructor.call(b);if(a){b.setRootNode(a)}},getRootNode:function(){return this.root},setRootNode:function(b){var a=this;a.root=b;if(a.fireEvent("beforeappend",null,b)!==false){b.set("root",true);b.updateInfo();b.commit();b.on({scope:a,insert:a.onNodeInsert,append:a.onNodeAppend,remove:a.onNodeRemove});a.relayEvents(b,["append","remove","move","insert","beforeappend","beforeremove","beforemove","beforeinsert","expand","collapse","beforeexpand","beforecollapse","sort","rootchange"]);a.nodeHash={};a.registerNode(b);a.fireEvent("append",null,b);a.fireEvent("rootchange",b)}return b},flatten:function(){return Ext.Object.getValues(this.nodeHash)},onNodeInsert:function(a,b){this.registerNode(b,true)},onNodeAppend:function(a,b){this.registerNode(b,true)},onNodeRemove:function(a,b){this.unregisterNode(b,true)},onNodeIdChanged:function(c,d,a){var b=this.nodeHash;b[a]=c;delete b[d||c.internalId]},getNodeById:function(a){return this.nodeHash[a]},registerNode:function(c,a){var b=this;b.nodeHash[c.getId()||c.internalId]=c;c.on("idchanged",b.onNodeIdChanged,b);if(a===true){c.eachChild(function(d){b.registerNode(d,true)})}},unregisterNode:function(b,a){delete this.nodeHash[b.getId()||b.internalId];if(a===true){b.eachChild(function(c){this.unregisterNode(c,true)},this)}},sort:function(b,a){this.getRootNode().sort(b,a)},filter:function(b,a){this.getRootNode().filter(b,a)}});Ext.define("Ext.data.TreeStore",{extend:"Ext.data.AbstractStore",alias:"store.tree",requires:["Ext.util.Sorter","Ext.data.Tree","Ext.data.NodeInterface"],clearOnLoad:true,clearRemovedOnLoad:true,nodeParam:"node",defaultRootId:"root",defaultRootProperty:"children",rootProperty:"children",folderSort:false,constructor:function(c){var e=this,b,a,d;c=Ext.apply({},c);a=c.fields||e.fields;if(!a){c.fields=[{name:"text",type:"string"}];d=c.defaultRootProperty||e.defaultRootProperty;if(d!==e.defaultRootProperty){c.fields.push({name:d,type:"auto",defaultValue:null,persist:false})}}e.callParent([c]);e.tree=new Ext.data.Tree();e.relayEvents(e.tree,["append","remove","move","insert","beforeappend","beforeremove","beforemove","beforeinsert","expand","collapse","beforeexpand","beforecollapse","sort","rootchange"]);e.tree.on({scope:e,remove:e.onNodeRemove,beforeexpand:e.onBeforeNodeExpand,beforecollapse:e.onBeforeNodeCollapse,append:e.onNodeAdded,insert:e.onNodeAdded,sort:e.onNodeSort});e.onBeforeSort();b=e.root;if(b){delete e.root;e.setRootNode(b)}if(Ext.isDefined(e.nodeParameter)){if(Ext.isDefined(Ext.global.console)){Ext.global.console.warn("Ext.data.TreeStore: nodeParameter has been deprecated. Please use nodeParam instead.")}e.nodeParam=e.nodeParameter;delete e.nodeParameter}},setProxy:function(c){var a,b;if(c instanceof Ext.data.proxy.Proxy){b=Ext.isEmpty(c.getReader().root)}else{if(Ext.isString(c)){b=true}else{a=c.reader;b=!(a&&!Ext.isEmpty(a.root))}}c=this.callParent(arguments);if(b){a=c.getReader();a.root=this.defaultRootProperty;a.buildExtractors(true)}},onBeforeSort:function(){if(this.folderSort){this.sort({property:"leaf",direction:"ASC"},"prepend",false)}},onBeforeNodeExpand:function(b,c,a){if(b.isLoaded()){Ext.callback(c,a||b,[b.childNodes])}else{if(b.isLoading()){this.on("load",function(){Ext.callback(c,a||b,[b.childNodes])},this,{single:true})}else{this.read({node:b,callback:function(){Ext.callback(c,a||b,[b.childNodes])}})}}},getNewRecords:function(){return Ext.Array.filter(this.tree.flatten(),this.filterNew)},getUpdatedRecords:function(){return Ext.Array.filter(this.tree.flatten(),this.filterUpdated)},onBeforeNodeCollapse:function(b,c,a){c.call(a||b,b.childNodes)},onNodeRemove:function(b,d,a){var c=this,e=c.removed;if(!d.isReplace&&Ext.Array.indexOf(e,d)==-1){e.push(d)}if(c.autoSync&&!c.autoSyncSuspended&&!a){c.sync()}},onNodeAdded:function(c,e){var d=this,b=d.getProxy(),a=b.getReader(),g=e.raw||e[e.persistenceProperty],h;Ext.Array.remove(d.removed,e);if(!e.isLeaf()){h=a.getRoot(g);if(h){d.fillNode(e,a.extractData(h));delete g[a.root]}}if(d.autoSync&&!d.autoSyncSuspended&&(e.phantom||e.dirty)){d.sync()}},onNodeSort:function(){if(this.autoSync&&!this.autoSyncSuspended){this.sync()}},setRootNode:function(a,e){var d=this,c=d.model,b=c.prototype.idProperty;a=a||{};if(!a.isModel){Ext.applyIf(a,{id:d.defaultRootId,text:"Root",allowDrag:false});if(a[b]===undefined){a[b]=d.defaultRootId}Ext.data.NodeInterface.decorate(c);a=Ext.ModelManager.create(a,c)}else{if(a.isModel&&!a.isNode){Ext.data.NodeInterface.decorate(c)}}d.getProxy().getReader().buildExtractors(true);d.tree.setRootNode(a);if(e!==true&&!a.isLoaded()&&(d.autoLoad===true||a.isExpanded())){d.load({node:a})}return a},getRootNode:function(){return this.tree.getRootNode()},getNodeById:function(a){return this.tree.getNodeById(a)},getById:function(a){return this.getNodeById(a)},load:function(a){a=a||{};a.params=a.params||{};var c=this,b=a.node||c.tree.getRootNode();if(!b){b=c.setRootNode({expanded:true},true)}a.id=b.getId();if(c.clearOnLoad){if(c.clearRemovedOnLoad){c.clearRemoved(b)}c.tree.un("remove",c.onNodeRemove,c);b.removeAll(false);c.tree.on("remove",c.onNodeRemove,c)}Ext.applyIf(a,{node:b});a.params[c.nodeParam]=b?b.getId():"root";if(b){b.set("loading",true)}return c.callParent([a])},clearRemoved:function(b){var k=this,e=k.removed,a=b.getId(),d=e.length,c=d,n={},h=[],m={},j,g,l;if(b===k.getRootNode()){k.removed=[];return}for(;c--;){j=e[c];m[j.getId()]=j}for(c=d;c--;){j=e[c];g=j;while(g&&g.getId()!==a){l=g.get("parentId");g=g.parentNode||k.getNodeById(l)||m[l]}if(g){n[j.getId()]=j}}for(c=0;c<d;c++){j=e[c];if(!n[j.getId()]){h.push(j)}}k.removed=h},fillNode:function(b,c){var h=this,e=c?c.length:0,g=h.sorters,d,k,j=false,a=e&&h.sortOnLoad&&!h.remoteSort&&g&&g.items&&g.items.length,m,l;for(d=1;d<e;d++){m=c[d];l=c[d-1];j=m[m.persistenceProperty].index!=l[l.persistenceProperty].index;if(j){break}}if(a){if(j){h.sorters.insert(0,h.indexSorter)}k=new Ext.util.MixedCollection();k.addAll(c);k.sort(h.sorters.items);c=k.items;h.sorters.remove(h.indexSorter)}else{if(j){Ext.Array.sort(c,h.sortByIndex)}}b.set("loaded",true);for(d=0;d<e;d++){b.appendChild(c[d],undefined,true)}return c},sortByIndex:function(b,a){return b[b.persistenceProperty].index-a[a.persistenceProperty].index},onProxyLoad:function(b){var d=this,e=b.wasSuccessful(),a=b.getRecords(),c=b.node;d.loading=false;c.set("loading",false);if(e){if(!d.clearOnLoad){a=d.cleanRecords(c,a)}a=d.fillNode(c,a)}d.fireEvent("read",d,b.node,a,e);d.fireEvent("load",d,b.node,a,e);Ext.callback(b.callback,b.scope||d,[a,b,e])},onCreateRecords:function(c){this.callParent(arguments);var d=0,b=c.length,a=this.tree,e;for(;d<b;++d){e=c[d];a.onNodeIdChanged(e,null,e.getId())}},cleanRecords:function(g,b){var e={},j=g.childNodes,d=0,a=j.length,c=[],h;for(;d<a;++d){e[j[d].getId()]=true}for(d=0,a=b.length;d<a;++d){h=b[d];if(!e[h.getId()]){c.push(h)}}return c},removeAll:function(){var a=this.getRootNode();if(a){a.destroy(true)}this.fireEvent("clear",this)},doSort:function(a){var b=this;if(b.remoteSort){b.load()}else{b.tree.sort(a,true);b.fireEvent("datachanged",b);b.fireEvent("refresh",b)}b.fireEvent("sort",b)}},function(){var a=this.prototype;a.indexSorter=new Ext.util.Sorter({sorterFn:a.sortByIndex})});Ext.define("Ext.data.UuidGenerator",(function(){var h=Math.pow(2,14),g=Math.pow(2,16),e=Math.pow(2,28),c=Math.pow(2,32);function a(k,j){var i=k.toString(16);if(i.length>j){i=i.substring(i.length-j)}else{if(i.length<j){i=Ext.String.leftPad(i,j,"0")}}return i}function d(k,j){var i=Math.random()*(j-k+1);return Math.floor(i)+k}function b(j){if(typeof(j)=="number"){var i=Math.floor(j/c);return{lo:Math.floor(j-i*c),hi:i}}return j}return{extend:"Ext.data.IdGenerator",alias:"idgen.uuid",id:"uuid",version:4,constructor:function(){var i=this;i.callParent(arguments);i.parts=[];i.init()},generate:function(){var j=this,k=j.parts,i=j.timestamp;k[0]=a(i.lo,8);k[1]=a(i.hi&65535,4);k[2]=a(((i.hi>>>16)&4095)|(j.version<<12),4);k[3]=a(128|((j.clockSeq>>>8)&63),2)+a(j.clockSeq&255,2);k[4]=a(j.salt.hi,4)+a(j.salt.lo,8);if(j.version==4){j.init()}else{++i.lo;if(i.lo>=c){i.lo=0;++i.hi}}return k.join("-").toLowerCase()},getRecId:function(i){return i.getId()},init:function(){var j=this,i,k;if(j.version==4){j.clockSeq=d(0,h-1);i=j.salt||(j.salt={});k=j.timestamp||(j.timestamp={});i.lo=d(0,c-1);i.hi=d(0,g-1);k.lo=d(0,c-1);k.hi=d(0,e-1)}else{j.salt=b(j.salt);j.timestamp=b(j.timestamp);j.salt.hi|=256}},reconfigure:function(i){Ext.apply(this,i);this.init()}}}()));Ext.define("Ext.data.reader.Xml",{extend:"Ext.data.reader.Reader",alternateClassName:"Ext.data.XmlReader",alias:"reader.xml",createAccessor:function(b){var a=this;if(Ext.isEmpty(b)){return Ext.emptyFn}if(Ext.isFunction(b)){return b}return function(c){return a.getNodeValue(Ext.DomQuery.selectNode(b,c))}},getNodeValue:function(a){if(a&&a.firstChild){return a.firstChild.nodeValue}return undefined},getResponseData:function(a){var c=a.responseXML,b,d;if(!c){d="XML data not found in the response";b=new Ext.data.ResultSet({total:0,count:0,records:[],success:false,message:d});this.fireEvent("exception",this,a,b);Ext.Logger.warn(d);return b}return this.readRecords(c)},getData:function(a){return a.documentElement||a},getRoot:function(b){var c=b.nodeName,a=this.root;if(!a||(c&&c==a)){return b}else{if(Ext.DomQuery.isXml(b)){return Ext.DomQuery.selectNode(a,b)}}},extractData:function(a){var b=this.record;if(b!=a.nodeName){a=Ext.DomQuery.select(b,a)}else{a=[a]}return this.callParent([a])},getAssociatedDataRoot:function(b,a){return Ext.DomQuery.select(a,b)[0]},readRecords:function(a){if(Ext.isArray(a)){a=a[0]}this.xmlData=a;return this.callParent([a])},createFieldAccessExpression:function(e,d,c){var b=e.mapping||e.name,a;if(typeof b==="function"){a=d+".mapping("+c+", this)"}else{a='me.getNodeValue(Ext.DomQuery.selectNode("'+b+'", '+c+"))"}return a}});Ext.define("Ext.data.writer.Xml",{extend:"Ext.data.writer.Writer",alternateClassName:"Ext.data.XmlWriter",alias:"writer.xml",documentRoot:"xmlData",defaultDocumentRoot:"xmlData",header:"",record:"record",writeRecords:function(a,b){var h=this,d=[],c=0,g=b.length,j=h.documentRoot,e=h.record,m=b.length!==1,l,k;d.push(h.header||"");if(!j&&m){j=h.defaultDocumentRoot}if(j){d.push("<",j,">")}for(;c<g;++c){l=b[c];d.push("<",e,">");for(k in l){if(l.hasOwnProperty(k)){d.push("<",k,">",l[k],"</",k,">")}}d.push("</",e,">")}if(j){d.push("</",j,">")}a.xmlData=d.join("");return a}});Ext.define("Ext.data.XmlStore",{extend:"Ext.data.Store",alias:"store.xml",requires:["Ext.data.proxy.Ajax","Ext.data.reader.Xml","Ext.data.writer.Xml"],constructor:function(a){a=Ext.apply({proxy:{type:"ajax",reader:"xml",writer:"xml"}},a);this.callParent([a])}});Ext.define("Ext.data.association.BelongsTo",{extend:"Ext.data.association.Association",alternateClassName:"Ext.data.BelongsToAssociation",alias:"association.belongsto",constructor:function(c){this.callParent(arguments);var e=this,a=e.ownerModel.prototype,g=e.associatedName,d=e.getterName||"get"+g,b=e.setterName||"set"+g;Ext.applyIf(e,{name:g,foreignKey:g.toLowerCase()+"_id",instanceName:g+"BelongsToInstance",associationKey:g.toLowerCase()});a[d]=e.createGetter();a[b]=e.createSetter()},createSetter:function(){var b=this,a=b.foreignKey;return function(e,c,d){if(e&&e.isModel){e=e.getId()}this.set(a,e);if(Ext.isFunction(c)){c={callback:c,scope:d||this}}if(Ext.isObject(c)){return this.save(c)}}},createGetter:function(){var d=this,e=d.associatedName,g=d.associatedModel,c=d.foreignKey,b=d.primaryKey,a=d.instanceName;return function(k,l){k=k||{};var j=this,m=j.get(c),n,h,i;if(k.reload===true||j[a]===undefined){h=Ext.ModelManager.create({},e);h.set(b,m);if(typeof k=="function"){k={callback:k,scope:l||j}}n=k.success;k.success=function(o){j[a]=o;if(n){n.apply(this,arguments)}};g.load(m,k);j[a]=h;return h}else{h=j[a];i=[h];l=l||k.scope||j;Ext.callback(k,l,i);Ext.callback(k.success,l,i);Ext.callback(k.failure,l,i);Ext.callback(k.callback,l,i);return h}}},read:function(b,a,c){b[this.instanceName]=a.read([c]).records[0]}});Ext.define("Ext.util.Inflector",{singleton:true,plurals:[[(/(quiz)$/i),"$1zes"],[(/^(ox)$/i),"$1en"],[(/([m|l])ouse$/i),"$1ice"],[(/(matr|vert|ind)ix|ex$/i),"$1ices"],[(/(x|ch|ss|sh)$/i),"$1es"],[(/([^aeiouy]|qu)y$/i),"$1ies"],[(/(hive)$/i),"$1s"],[(/(?:([^f])fe|([lr])f)$/i),"$1$2ves"],[(/sis$/i),"ses"],[(/([ti])um$/i),"$1a"],[(/(buffal|tomat|potat)o$/i),"$1oes"],[(/(bu)s$/i),"$1ses"],[(/(alias|status|sex)$/i),"$1es"],[(/(octop|vir)us$/i),"$1i"],[(/(ax|test)is$/i),"$1es"],[(/^person$/),"people"],[(/^man$/),"men"],[(/^(child)$/),"$1ren"],[(/s$/i),"s"],[(/$/),"s"]],singulars:[[(/(quiz)zes$/i),"$1"],[(/(matr)ices$/i),"$1ix"],[(/(vert|ind)ices$/i),"$1ex"],[(/^(ox)en/i),"$1"],[(/(alias|status)es$/i),"$1"],[(/(octop|vir)i$/i),"$1us"],[(/(cris|ax|test)es$/i),"$1is"],[(/(shoe)s$/i),"$1"],[(/(o)es$/i),"$1"],[(/(bus)es$/i),"$1"],[(/([m|l])ice$/i),"$1ouse"],[(/(x|ch|ss|sh)es$/i),"$1"],[(/(m)ovies$/i),"$1ovie"],[(/(s)eries$/i),"$1eries"],[(/([^aeiouy]|qu)ies$/i),"$1y"],[(/([lr])ves$/i),"$1f"],[(/(tive)s$/i),"$1"],[(/(hive)s$/i),"$1"],[(/([^f])ves$/i),"$1fe"],[(/(^analy)ses$/i),"$1sis"],[(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i),"$1$2sis"],[(/([ti])a$/i),"$1um"],[(/(n)ews$/i),"$1ews"],[(/people$/i),"person"],[(/s$/i),""]],uncountable:["sheep","fish","series","species","money","rice","information","equipment","grass","mud","offspring","deer","means"],singular:function(b,a){this.singulars.unshift([b,a])},plural:function(b,a){this.plurals.unshift([b,a])},clearSingulars:function(){this.singulars=[]},clearPlurals:function(){this.plurals=[]},isTransnumeral:function(a){return Ext.Array.indexOf(this.uncountable,a)!=-1},pluralize:function(g){if(this.isTransnumeral(g)){return g}var e=this.plurals,d=e.length,a,c,b;for(b=0;b<d;b++){a=e[b];c=a[0];if(c==g||(c.test&&c.test(g))){return g.replace(c,a[1])}}return g},singularize:function(g){if(this.isTransnumeral(g)){return g}var e=this.singulars,d=e.length,a,c,b;for(b=0;b<d;b++){a=e[b];c=a[0];if(c==g||(c.test&&c.test(g))){return g.replace(c,a[1])}}return g},classify:function(a){return Ext.String.capitalize(this.singularize(a))},ordinalize:function(d){var b=parseInt(d,10),c=b%10,a=b%100;if(11<=a&&a<=13){return d+"th"}else{switch(c){case 1:return d+"st";case 2:return d+"nd";case 3:return d+"rd";default:return d+"th"}}}},function(){var b={alumnus:"alumni",cactus:"cacti",focus:"foci",nucleus:"nuclei",radius:"radii",stimulus:"stimuli",ellipsis:"ellipses",paralysis:"paralyses",oasis:"oases",appendix:"appendices",index:"indexes",beau:"beaux",bureau:"bureaux",tableau:"tableaux",woman:"women",child:"children",man:"men",corpus:"corpora",criterion:"criteria",curriculum:"curricula",genus:"genera",memorandum:"memoranda",phenomenon:"phenomena",foot:"feet",goose:"geese",tooth:"teeth",antenna:"antennae",formula:"formulae",nebula:"nebulae",vertebra:"vertebrae",vita:"vitae"},a;for(a in b){this.plural(a,b[a]);this.singular(b[a],a)}});Ext.define("Ext.data.association.HasMany",{extend:"Ext.data.association.Association",alternateClassName:"Ext.data.HasManyAssociation",requires:["Ext.util.Inflector"],alias:"association.hasmany",constructor:function(c){var d=this,a,b;d.callParent(arguments);d.name=d.name||Ext.util.Inflector.pluralize(d.associatedName.toLowerCase());a=d.ownerModel.prototype;b=d.name;Ext.applyIf(d,{storeName:b+"Store",foreignKey:d.ownerName.toLowerCase()+"_id"});a[b]=d.createStore()},createStore:function(){var h=this,i=h.associatedModel,c=h.storeName,d=h.foreignKey,a=h.primaryKey,g=h.filterProperty,b=h.autoLoad,e=h.storeConfig||{};return function(){var m=this,k,l,j={};if(m[c]===undefined){if(g){l={property:g,value:m.get(g),exactMatch:true}}else{l={property:d,value:m.get(a),exactMatch:true}}j[d]=m.get(a);k=Ext.apply({},e,{model:i,filters:[l],remoteFilter:false,modelDefaults:j});m[c]=Ext.data.AbstractStore.create(k);if(b){m[c].load()}}return m[c]}},read:function(d,b,j){var g=d[this.name](),c,e,a,h;g.add(b.read(j).records);c=this.associatedModel.prototype.associations.findBy(function(i){return i.type==="belongsTo"&&i.associatedName===d.$className});if(c){e=g.data.items;a=e.length;for(h=0;h<a;h++){e[h][c.instanceName]=d}}}});Ext.define("Ext.data.association.HasOne",{extend:"Ext.data.association.Association",alternateClassName:"Ext.data.HasOneAssociation",alias:"association.hasone",constructor:function(c){this.callParent(arguments);var e=this,a=e.ownerModel.prototype,g=e.associatedName,d=e.getterName||"get"+g,b=e.setterName||"set"+g;Ext.applyIf(e,{name:g,foreignKey:g.toLowerCase()+"_id",instanceName:g+"HasOneInstance",associationKey:g.toLowerCase()});a[d]=e.createGetter();a[b]=e.createSetter()},createSetter:function(){var b=this,c=b.ownerModel,a=b.foreignKey;return function(g,d,e){if(g&&g.isModel){g=g.getId()}this.set(a,g);if(Ext.isFunction(d)){d={callback:d,scope:e||this}}if(Ext.isObject(d)){return this.save(d)}}},createGetter:function(){var d=this,g=d.ownerModel,e=d.associatedName,h=d.associatedModel,c=d.foreignKey,b=d.primaryKey,a=d.instanceName;return function(l,m){l=l||{};var k=this,n=k.get(c),o,i,j;if(l.reload===true||k[a]===undefined){i=Ext.ModelManager.create({},e);i.set(b,n);if(typeof l=="function"){l={callback:l,scope:m||k}}o=l.success;l.success=function(p){k[a]=p;if(o){o.apply(this,arguments)}};h.load(n,l);k[a]=i;return i}else{i=k[a];j=[i];m=m||l.scope||k;Ext.callback(l,m,j);Ext.callback(l.success,m,j);Ext.callback(l.failure,m,j);Ext.callback(l.callback,m,j);return i}}},read:function(c,a,e){var b=this.associatedModel.prototype.associations.findBy(function(g){return g.type==="belongsTo"&&g.associatedName===c.$className}),d=a.read([e]).records[0];c[this.instanceName]=d;if(b){d[b.instanceName]=c}}});Ext.define("Ext.data.proxy.WebStorage",{extend:"Ext.data.proxy.Client",alternateClassName:"Ext.data.WebStorageProxy",requires:["Ext.data.SequentialIdGenerator"],id:undefined,constructor:function(a){this.callParent(arguments);this.cache={};this.id=this.id||(this.store?this.store.storeId:undefined);this.initialize()},create:function(e,k,l){var j=this,d=e.records,c=d.length,a=j.getIds(),b,h,g;e.setStarted();if(j.isHierarchical===undefined){j.isHierarchical=!!d[0].isNode;if(j.isHierarchical){j.getStorageObject().setItem(j.getTreeKey(),true)}}for(g=0;g<c;g++){h=d[g];if(h.phantom){h.phantom=false;b=j.getNextId()}else{b=h.getId()}j.setRecord(h,b);h.commit();a.push(b)}j.setIds(a);e.setCompleted();e.setSuccessful();if(typeof k=="function"){k.call(l||j,e)}},read:function(g,m,o){var l=this,e=[],j=0,n=true,d=l.model,a,c,k,h,b;g.setStarted();if(l.isHierarchical){e=l.getTreeData()}else{a=l.getIds();c=a.length;b=g.id;if(b){h=l.getRecord(b);if(h!==null){k=new d(h,b,h)}if(k){e.push(k)}else{n=false}}else{for(;j<c;j++){b=a[j];h=l.getRecord(b);e.push(new d(h,b,h))}}}if(n){g.setSuccessful()}g.setCompleted();g.resultSet=Ext.create("Ext.data.ResultSet",{records:e,total:e.length,loaded:true});if(typeof m=="function"){m.call(o||l,g)}},update:function(e,j,k){var d=e.records,c=d.length,a=this.getIds(),h,b,g;e.setStarted();for(g=0;g<c;g++){h=d[g];this.setRecord(h);h.commit();b=h.getId();if(b!==undefined&&Ext.Array.indexOf(a,b)==-1){a.push(b)}}this.setIds(a);e.setCompleted();e.setSuccessful();if(typeof j=="function"){j.call(k||this,e)}},destroy:function(d,k,l){var g=this,c=d.records,a=g.getIds(),h=a.length,m=[],j={},e=c.length,b;d.setStarted();for(;e--;){Ext.apply(j,g.removeRecord(c[e]))}for(e=0;e<h;e++){b=a[e];if(!j[b]){m.push(b)}}g.setIds(m);d.setCompleted();d.setSuccessful();if(typeof k=="function"){k.call(l||g,d)}},getRecord:function(d){var b=this,a=b.cache,c=!a[d]?Ext.decode(b.getStorageObject().getItem(b.getRecordKey(d))):a[d];if(!c){return null}a[d]=c;c[b.model.prototype.idProperty]=d;return c},setRecord:function(k,c){if(c){k.setId(c)}else{c=k.getId()}var m=this,a=k.data,h={},j=m.model,l=j.prototype.fields.items,d=l.length,g=0,n,b,e,o;for(;g<d;g++){n=l[g];b=n.name;if(n.persist){h[b]=a[b]}}delete h[m.model.prototype.idProperty];if(k.isNode&&k.get("depth")===1){delete h.parentId}e=m.getStorageObject();o=m.getRecordKey(c);m.cache[c]=h;e.removeItem(o);e.setItem(o,Ext.encode(h))},removeRecord:function(a){var d=this,g=a.getId(),b={},c,e;b[g]=a;d.getStorageObject().removeItem(d.getRecordKey(g));delete d.cache[g];if(a.childNodes){e=a.childNodes;for(c=e.length;c--;){Ext.apply(b,d.removeRecord(e[c]))}}return b},getRecordKey:function(a){if(a.isModel){a=a.getId()}return Ext.String.format("{0}-{1}",this.id,a)},getRecordCounterKey:function(){return Ext.String.format("{0}-counter",this.id)},getTreeKey:function(){return Ext.String.format("{0}-tree",this.id)},getIds:function(){var g=this,d=(g.getStorageObject().getItem(g.id)||"").split(","),b=g.model,e=d.length,a=b.prototype.fields.get(b.prototype.idProperty).type.type==="string",c;if(e==1&&d[0]===""){d=[]}else{for(c=0;c<e;c++){d[c]=a?d[c]:+d[c]}}return d},setIds:function(a){var b=this.getStorageObject(),c=a.join(",");b.removeItem(this.id);if(!Ext.isEmpty(c)){b.setItem(this.id,c)}},getNextId:function(){var d=this,e=d.getStorageObject(),c=d.getRecordCounterKey(),b=d.model,a=b.prototype.fields.get(b.prototype.idProperty).type.type==="string",g;g=d.idGenerator.generate();e.setItem(c,g);if(!a){g=+g}return g},getTreeData:function(){var n=this,a=n.getIds(),e=a.length,j=[],b={},o=[],k=0,h=n.model,q=h.prototype.idProperty,g,m,p,l,d,c;for(;k<e;k++){c=a[k];m=n.getRecord(c);j.push(m);b[c]=m;if(!m.parentId){o.push(m)}}g=o.length;Ext.Array.sort(j,n.sortByParentId);for(k=g;k<e;k++){m=j[k];l=m.parentId;if(!p||p[q]!==l){p=b[l];p.children=d=[]}d.push(m)}for(k=e;k--;){m=j[k];if(!m.children&&!m.leaf){m.loaded=true}}for(k=g;k--;){m=o[k];o[k]=new h(m,m[q],m)}return o},sortByParentId:function(b,a){return(b.parentId||0)-(a.parentId||0)},initialize:function(){var b=this,a=b.getStorageObject(),c=+a.getItem(b.getRecordCounterKey());a.setItem(b.id,a.getItem(b.id)||"");if(a.getItem(b.getTreeKey())){b.isHierarchical=true}b.idGenerator=new Ext.data.SequentialIdGenerator({seed:c?c+1:1})},clear:function(){var d=this,e=d.getStorageObject(),c=d.getIds(),a=c.length,b;for(b=0;b<a;b++){e.removeItem(d.getRecordKey(c[b]))}e.removeItem(d.getRecordCounterKey());e.removeItem(d.getTreeKey());e.removeItem(d.id);d.cache={}},getStorageObject:function(){}});Ext.define("Ext.data.proxy.LocalStorage",{extend:"Ext.data.proxy.WebStorage",alias:"proxy.localstorage",alternateClassName:"Ext.data.LocalStorageProxy",getStorageObject:function(){return window.localStorage}});Ext.define("Ext.data.proxy.Rest",{extend:"Ext.data.proxy.Ajax",alternateClassName:"Ext.data.RestProxy",alias:"proxy.rest",appendId:true,batchActions:false,buildUrl:function(g){var e=this,c=g.operation,b=c.records||[],a=b[0],h=e.format,d=e.getUrl(g),i=a?a.getId():c.id;if(e.appendId&&i){if(!d.match(/\/$/)){d+="/"}d+=i}if(h){if(!d.match(/\.$/)){d+="."}d+=h}g.url=d;return e.callParent(arguments)}},function(){Ext.apply(this.prototype,{actionMethods:{create:"POST",read:"GET",update:"PUT",destroy:"DELETE"}})});Ext.define("Ext.data.proxy.SessionStorage",{extend:"Ext.data.proxy.WebStorage",alias:"proxy.sessionstorage",alternateClassName:"Ext.data.SessionStorageProxy",getStorageObject:function(){return window.sessionStorage}});Ext.define("Ext.dd.DDTarget",{extend:"Ext.dd.DragDrop",constructor:function(c,a,b){if(c){this.initTarget(c,a,b)}},getDragEl:Ext.emptyFn,isValidHandleChild:Ext.emptyFn,startDrag:Ext.emptyFn,endDrag:Ext.emptyFn,onDrag:Ext.emptyFn,onDragDrop:Ext.emptyFn,onDragEnter:Ext.emptyFn,onDragOut:Ext.emptyFn,onDragOver:Ext.emptyFn,onInvalidDrop:Ext.emptyFn,onMouseDown:Ext.emptyFn,onMouseUp:Ext.emptyFn,setXConstraint:Ext.emptyFn,setYConstraint:Ext.emptyFn,resetConstraints:Ext.emptyFn,clearConstraints:Ext.emptyFn,clearTicks:Ext.emptyFn,setInitPosition:Ext.emptyFn,setDragElId:Ext.emptyFn,setHandleElId:Ext.emptyFn,setOuterHandleElId:Ext.emptyFn,addInvalidHandleClass:Ext.emptyFn,addInvalidHandleId:Ext.emptyFn,addInvalidHandleType:Ext.emptyFn,removeInvalidHandleClass:Ext.emptyFn,removeInvalidHandleId:Ext.emptyFn,removeInvalidHandleType:Ext.emptyFn,toString:function(){return("DDTarget "+this.id)}});Ext.define("Ext.dd.DragTracker",{uses:["Ext.util.Region"],mixins:{observable:"Ext.util.Observable"},active:false,trackOver:false,tolerance:5,autoStart:false,constructor:function(a){var b=this;Ext.apply(b,a);b.addEvents("mouseover","mouseout","mousedown","mouseup","mousemove","beforedragstart","dragstart","dragend","drag");b.dragRegion=new Ext.util.Region(0,0,0,0);if(b.el){b.initEl(b.el)}b.mixins.observable.constructor.call(b);if(b.disabled){b.disable()}},initEl:function(a){var b=this;b.el=Ext.get(a);b.handle=Ext.get(b.delegate);b.delegate=b.handle?undefined:b.delegate;if(!b.handle){b.handle=b.el}b.mon(b.handle,{mousedown:b.onMouseDown,delegate:b.delegate,scope:b});if(b.trackOver||b.overCls){b.mon(b.handle,{mouseover:b.onMouseOver,mouseout:b.onMouseOut,delegate:b.delegate,scope:b})}},disable:function(){this.disabled=true},enable:function(){this.disabled=false},destroy:function(){this.clearListeners();delete this.el},onMouseOver:function(c,b){var a=this;if(!a.disabled){if(Ext.EventManager.contains(c)||a.delegate){a.mouseIsOut=false;if(a.overCls){a.el.addCls(a.overCls)}a.fireEvent("mouseover",a,c,a.delegate?c.getTarget(a.delegate,b):a.handle)}}},onMouseOut:function(b){var a=this;if(a.mouseIsDown){a.mouseIsOut=true}else{if(a.overCls){a.el.removeCls(a.overCls)}a.fireEvent("mouseout",a,b)}},onMouseDown:function(d,c){var b=this,a;if(b.disabled||d.dragTracked){return}b.dragTarget=b.delegate?c:b.handle.dom;b.startXY=b.lastXY=d.getXY();b.startRegion=Ext.fly(b.dragTarget).getRegion();if(b.fireEvent("mousedown",b,d)===false||b.fireEvent("beforedragstart",b,d)===false||b.onBeforeStart(d)===false){return}b.mouseIsDown=true;d.dragTracked=true;a=b.el.dom;if(Ext.isIE&&a.setCapture){a.setCapture()}if(b.preventDefault!==false){d.preventDefault()}Ext.getDoc().on({scope:b,mouseup:b.onMouseUp,mousemove:b.onMouseMove,selectstart:b.stopSelect});if(b.autoStart){b.timer=Ext.defer(b.triggerStart,b.autoStart===true?1000:b.autoStart,b,[d])}},onMouseMove:function(g,d){var b=this,c=g.getXY(),a=b.startXY;g.preventDefault();b.lastXY=c;if(!b.active){if(Math.max(Math.abs(a[0]-c[0]),Math.abs(a[1]-c[1]))>b.tolerance){b.triggerStart(g)}else{return}}if(b.fireEvent("mousemove",b,g)===false){b.onMouseUp(g)}else{b.onDrag(g);b.fireEvent("drag",b,g)}},onMouseUp:function(b){var a=this;a.mouseIsDown=false;if(a.mouseIsOut){a.mouseIsOut=false;a.onMouseOut(b)}b.preventDefault();if(Ext.isIE&&document.releaseCapture){document.releaseCapture()}a.fireEvent("mouseup",a,b);a.endDrag(b)},endDrag:function(d){var b=this,c=Ext.getDoc(),a=b.active;c.un("mousemove",b.onMouseMove,b);c.un("mouseup",b.onMouseUp,b);c.un("selectstart",b.stopSelect,b);b.clearStart();b.active=false;if(a){b.onEnd(d);b.fireEvent("dragend",b,d)}delete b._constrainRegion;delete Ext.EventObject.dragTracked},triggerStart:function(b){var a=this;a.clearStart();a.active=true;a.onStart(b);a.fireEvent("dragstart",a,b)},clearStart:function(){var a=this.timer;if(a){clearTimeout(a);delete this.timer}},stopSelect:function(a){a.stopEvent();return false},onBeforeStart:function(a){},onStart:function(a){},onDrag:function(a){},onEnd:function(a){},getDragTarget:function(){return this.dragTarget},getDragCt:function(){return this.el},getConstrainRegion:function(){var a=this;if(a.constrainTo){if(a.constrainTo instanceof Ext.util.Region){return a.constrainTo}if(!a._constrainRegion){a._constrainRegion=Ext.fly(a.constrainTo).getViewRegion()}}else{if(!a._constrainRegion){a._constrainRegion=a.getDragCt().getViewRegion()}}return a._constrainRegion},getXY:function(a){return a?this.constrainModes[a](this,this.lastXY):this.lastXY},getOffset:function(c){var b=this.getXY(c),a=this.startXY;return[b[0]-a[0],b[1]-a[1]]},constrainModes:{point:function(b,d){var c=b.dragRegion,a=b.getConstrainRegion();if(!a){return d}c.x=c.left=c[0]=c.right=d[0];c.y=c.top=c[1]=c.bottom=d[1];c.constrainTo(a);return[c.left,c.top]},dragTarget:function(c,g){var b=c.startXY,e=c.startRegion.copy(),a=c.getConstrainRegion(),d;if(!a){return g}e.translateBy(g[0]-b[0],g[1]-b[1]);if(e.right>a.right){g[0]+=d=(a.right-e.right);e.left+=d}if(e.left<a.left){g[0]+=(a.left-e.left)}if(e.bottom>a.bottom){g[1]+=d=(a.bottom-e.bottom);e.top+=d}if(e.top<a.top){g[1]+=(a.top-e.top)}return g}}});Ext.define("Ext.dd.DragZone",{extend:"Ext.dd.DragSource",constructor:function(b,a){this.callParent([b,a]);if(this.containerScroll){Ext.dd.ScrollManager.register(this.el)}},getDragData:function(a){return Ext.dd.Registry.getHandleFromEvent(a)},onInitDrag:function(a,b){this.proxy.update(this.dragData.ddel.cloneNode(true));this.onStartDrag(a,b);return true},afterRepair:function(){var a=this;if(Ext.enableFx){Ext.fly(a.dragData.ddel).highlight(a.repairHighlightColor)}a.dragging=false},getRepairXY:function(a){return Ext.fly(this.dragData.ddel).getXY()},destroy:function(){this.callParent();if(this.containerScroll){Ext.dd.ScrollManager.unregister(this.el)}}});Ext.define("Ext.dd.ScrollManager",{singleton:true,requires:["Ext.dd.DragDropManager"],constructor:function(){var a=Ext.dd.DragDropManager;a.fireEvents=Ext.Function.createSequence(a.fireEvents,this.onFire,this);a.stopDrag=Ext.Function.createSequence(a.stopDrag,this.onStop,this);this.doScroll=Ext.Function.bind(this.doScroll,this);this.ddmInstance=a;this.els={};this.dragEl=null;this.proc={}},onStop:function(a){var b=Ext.dd.ScrollManager;b.dragEl=null;b.clearProc()},triggerRefresh:function(){if(this.ddmInstance.dragCurrent){this.ddmInstance.refreshCache(this.ddmInstance.dragCurrent.groups)}},doScroll:function(){if(this.ddmInstance.dragCurrent){var a=this.proc,b=a.el,c=a.el.ddScrollConfig,d=c?c.increment:this.increment;if(!this.animate){if(b.scroll(a.dir,d)){this.triggerRefresh()}}else{b.scroll(a.dir,d,true,this.animDuration,this.triggerRefresh)}}},clearProc:function(){var a=this.proc;if(a.id){clearInterval(a.id)}a.id=0;a.el=null;a.dir=""},startProc:function(b,a){this.clearProc();this.proc.el=b;this.proc.dir=a;var d=b.ddScrollConfig?b.ddScrollConfig.ddGroup:undefined,c=(b.ddScrollConfig&&b.ddScrollConfig.frequency)?b.ddScrollConfig.frequency:this.frequency;if(d===undefined||this.ddmInstance.dragCurrent.ddGroup==d){this.proc.id=setInterval(this.doScroll,c)}},onFire:function(h,k){if(k||!this.ddmInstance.dragCurrent){return}if(!this.dragEl||this.dragEl!=this.ddmInstance.dragCurrent){this.dragEl=this.ddmInstance.dragCurrent;this.refreshCache()}var l=h.getXY(),m=h.getPoint(),i=this.proc,g=this.els,b,d,a,j;for(b in g){d=g[b];a=d._region;j=d.ddScrollConfig?d.ddScrollConfig:this;if(a&&a.contains(m)&&d.isScrollable()){if(a.bottom-m.y<=j.vthresh){if(i.el!=d){this.startProc(d,"down")}return}else{if(a.right-m.x<=j.hthresh){if(i.el!=d){this.startProc(d,"left")}return}else{if(m.y-a.top<=j.vthresh){if(i.el!=d){this.startProc(d,"up")}return}else{if(m.x-a.left<=j.hthresh){if(i.el!=d){this.startProc(d,"right")}return}}}}}}this.clearProc()},register:function(c){if(Ext.isArray(c)){for(var b=0,a=c.length;b<a;b++){this.register(c[b])}}else{c=Ext.get(c);this.els[c.id]=c}},unregister:function(c){if(Ext.isArray(c)){for(var b=0,a=c.length;b<a;b++){this.unregister(c[b])}}else{c=Ext.get(c);delete this.els[c.id]}},vthresh:25,hthresh:25,increment:100,frequency:500,animate:true,animDuration:0.4,ddGroup:undefined,refreshCache:function(){var a=this.els,b;for(b in a){if(typeof a[b]=="object"){a[b]._region=a[b].getRegion()}}}});Ext.define("Ext.dd.DropTarget",{extend:"Ext.dd.DDTarget",requires:["Ext.dd.ScrollManager"],constructor:function(b,a){this.el=Ext.get(b);Ext.apply(this,a);if(this.containerScroll){Ext.dd.ScrollManager.register(this.el)}this.callParent([this.el.dom,this.ddGroup||this.group,{isTarget:true}])},dropAllowed:Ext.baseCSSPrefix+"dd-drop-ok",dropNotAllowed:Ext.baseCSSPrefix+"dd-drop-nodrop",isTarget:true,isNotifyTarget:true,notifyEnter:function(a,c,b){if(this.overClass){this.el.addCls(this.overClass)}return this.dropAllowed},notifyOver:function(a,c,b){return this.dropAllowed},notifyOut:function(a,c,b){if(this.overClass){this.el.removeCls(this.overClass)}},notifyDrop:function(a,c,b){return false},destroy:function(){this.callParent();if(this.containerScroll){Ext.dd.ScrollManager.unregister(this.el)}}});Ext.define("Ext.dd.Registry",{singleton:true,constructor:function(){this.elements={};this.handles={};this.autoIdSeed=0},getId:function(b,a){if(typeof b=="string"){return b}var c=b.id;if(!c&&a!==false){c="extdd-"+(++this.autoIdSeed);b.id=c}return c},register:function(d,e){e=e||{};if(typeof d=="string"){d=document.getElementById(d)}e.ddel=d;this.elements[this.getId(d)]=e;if(e.isHandle!==false){this.handles[e.ddel.id]=e}if(e.handles){var c=e.handles,b,a;for(b=0,a=c.length;b<a;b++){this.handles[this.getId(c[b])]=e}}},unregister:function(d){var g=this.getId(d,false),e=this.elements[g],c,b,a;if(e){delete this.elements[g];if(e.handles){c=e.handles;for(b=0,a=c.length;b<a;b++){delete this.handles[this.getId(c[b],false)]}}}},getHandle:function(a){if(typeof a!="string"){a=a.id}return this.handles[a]},getHandleFromEvent:function(b){var a=b.getTarget();return a?this.handles[a.id]:null},getTarget:function(a){if(typeof a!="string"){a=a.id}return this.elements[a]},getTargetFromEvent:function(b){var a=b.getTarget();return a?this.elements[a.id]||this.handles[a.id]:null}});Ext.define("Ext.dd.DropZone",{extend:"Ext.dd.DropTarget",requires:["Ext.dd.Registry"],getTargetFromEvent:function(a){return Ext.dd.Registry.getTargetFromEvent(a)},onNodeEnter:function(d,a,c,b){},onNodeOver:function(d,a,c,b){return this.dropAllowed},onNodeOut:function(d,a,c,b){},onNodeDrop:function(d,a,c,b){return false},onContainerOver:function(a,c,b){return this.dropNotAllowed},onContainerDrop:function(a,c,b){return false},notifyEnter:function(a,c,b){return this.dropNotAllowed},notifyOver:function(a,c,b){var d=this.getTargetFromEvent(c);if(!d){if(this.lastOverNode){this.onNodeOut(this.lastOverNode,a,c,b);this.lastOverNode=null}return this.onContainerOver(a,c,b)}if(this.lastOverNode!=d){if(this.lastOverNode){this.onNodeOut(this.lastOverNode,a,c,b)}this.onNodeEnter(d,a,c,b);this.lastOverNode=d}return this.onNodeOver(d,a,c,b)},notifyOut:function(a,c,b){if(this.lastOverNode){this.onNodeOut(this.lastOverNode,a,c,b);this.lastOverNode=null}},notifyDrop:function(a,c,b){if(this.lastOverNode){this.onNodeOut(this.lastOverNode,a,c,b);this.lastOverNode=null}var d=this.getTargetFromEvent(c);return d?this.onNodeDrop(d,a,c,b):this.onContainerDrop(a,c,b)},triggerCacheRefresh:function(){Ext.dd.DDM.refreshCache(this.groups)}});Ext.define("Ext.direct.Event",{alias:"direct.event",requires:["Ext.direct.Manager"],status:true,constructor:function(a){Ext.apply(this,a)},getData:function(){return this.data}});Ext.define("Ext.direct.RemotingEvent",{extend:"Ext.direct.Event",alias:"direct.rpc",getTransaction:function(){return this.transaction||Ext.direct.Manager.getTransaction(this.tid)}});Ext.define("Ext.direct.ExceptionEvent",{extend:"Ext.direct.RemotingEvent",alias:"direct.exception",status:false});Ext.define("Ext.direct.Provider",{alias:"direct.provider",mixins:{observable:"Ext.util.Observable"},constructor:function(a){var b=this;Ext.apply(b,a);b.addEvents("connect","disconnect","data","exception");b.mixins.observable.constructor.call(b,a)},isConnected:function(){return false},connect:Ext.emptyFn,disconnect:Ext.emptyFn});Ext.define("Ext.direct.JsonProvider",{extend:"Ext.direct.Provider",alias:"direct.jsonprovider",uses:["Ext.direct.ExceptionEvent"],parseResponse:function(a){if(!Ext.isEmpty(a.responseText)){if(Ext.isObject(a.responseText)){return a.responseText}return Ext.decode(a.responseText)}return null},createEvents:function(b){var h=null,d=[],g,c=0,a;try{h=this.parseResponse(b)}catch(j){g=new Ext.direct.ExceptionEvent({data:j,xhr:b,code:Ext.direct.Manager.exceptions.PARSE,message:"Error parsing json response: \n\n "+h});return[g]}if(Ext.isArray(h)){for(a=h.length;c<a;++c){d.push(this.createEvent(h[c]))}}else{d.push(this.createEvent(h))}return d},createEvent:function(a){return Ext.create("direct."+a.type,a)}});Ext.define("Ext.direct.PollingProvider",{extend:"Ext.direct.JsonProvider",alias:"direct.pollingprovider",uses:["Ext.direct.ExceptionEvent"],requires:["Ext.Ajax","Ext.util.DelayedTask"],interval:3000,constructor:function(a){this.callParent(arguments);this.addEvents("beforepoll","poll")},isConnected:function(){return !!this.pollTask},connect:function(){var b=this,a=b.url;if(a&&!b.pollTask){b.pollTask=Ext.TaskManager.start({run:function(){if(b.fireEvent("beforepoll",b)!==false){if(Ext.isFunction(a)){a(b.baseParams)}else{Ext.Ajax.request({url:a,callback:b.onData,scope:b,params:b.baseParams})}}},interval:b.interval,scope:b});b.fireEvent("connect",b)}else{if(!a){}}},disconnect:function(){var a=this;if(a.pollTask){Ext.TaskManager.stop(a.pollTask);delete a.pollTask;a.fireEvent("disconnect",a)}},onData:function(e,h,b){var g=this,d=0,a,c;if(h){c=g.createEvents(b);for(a=c.length;d<a;++d){g.fireEvent("data",g,c[d])}}else{g.fireEvent("data",g,new Ext.direct.ExceptionEvent({data:null,code:Ext.direct.Manager.exceptions.TRANSPORT,message:"Unable to connect to the server.",xhr:b}))}}});Ext.define("Ext.direct.RemotingMethod",{constructor:function(c){var d=this,h=Ext.isDefined(c.params)?c.params:c.len,b,a,e,g;d.name=c.name;d.formHandler=c.formHandler;if(Ext.isNumber(h)){d.len=h;d.ordered=true}else{d.params=[];a=h.length;for(e=0;e<a;e++){g=h[e];b=Ext.isObject(g)?g.name:g;d.params.push(b)}}},getArgs:function(e,b,g){var c=[],d,a;if(this.ordered){if(this.len>0){if(b){for(d=0,a=b.length;d<a;d++){c.push(e[b[d]])}}else{if(g){c.push(e)}}}}else{c.push(e)}return c},getCallData:function(c){var e=this,g=null,a=e.len,h=e.params,i,d,b;if(e.ordered){i=c[a];d=c[a+1];if(a!==0){g=c.slice(0,a)}}else{g=Ext.apply({},c[0]);i=c[1];d=c[2];for(b in g){if(g.hasOwnProperty(b)){if(!Ext.Array.contains(h,b)){delete g[b]}}}}return{data:g,callback:i,scope:d}}});Ext.define("Ext.direct.Transaction",{alias:"direct.transaction",alternateClassName:"Ext.Direct.Transaction",statics:{TRANSACTION_ID:0},constructor:function(a){var b=this;Ext.apply(b,a);b.id=b.tid=++b.self.TRANSACTION_ID;b.retryCount=0},send:function(){this.provider.queueTransaction(this)},retry:function(){this.retryCount++;this.send()},getProvider:function(){return this.provider}});Ext.define("Ext.direct.RemotingProvider",{alias:"direct.remotingprovider",extend:"Ext.direct.JsonProvider",requires:["Ext.util.MixedCollection","Ext.util.DelayedTask","Ext.direct.Transaction","Ext.direct.RemotingMethod"],enableBuffer:10,maxRetries:1,timeout:undefined,constructor:function(a){var b=this;b.callParent(arguments);b.addEvents("beforecall","call");b.namespace=(Ext.isString(b.namespace))?Ext.ns(b.namespace):b.namespace||window;b.transactions=new Ext.util.MixedCollection();b.callBuffer=[]},initAPI:function(){var h=this.actions,e=this.namespace,g,b,c,d,a,j;for(g in h){if(h.hasOwnProperty(g)){b=e[g];if(!b){b=e[g]={}}c=h[g];for(d=0,a=c.length;d<a;++d){j=new Ext.direct.RemotingMethod(c[d]);b[j.name]=this.createHandler(g,j)}}}},createHandler:function(c,d){var b=this,a;if(!d.formHandler){a=function(){b.configureRequest(c,d,Array.prototype.slice.call(arguments,0))}}else{a=function(g,h,e){b.configureFormRequest(c,d,g,h,e)}}a.directCfg={action:c,method:d};return a},isConnected:function(){return !!this.connected},connect:function(){var a=this;if(a.url){a.initAPI();a.connected=true;a.fireEvent("connect",a)}else{if(!a.url){}}},disconnect:function(){var a=this;if(a.connected){a.connected=false;a.fireEvent("disconnect",a)}},runCallback:function(e,b){var d=!!b.status,c=d?"success":"failure",g,a;if(e&&e.callback){g=e.callback;a=Ext.isDefined(b.result)?b.result:b.data;if(Ext.isFunction(g)){g(a,b,d)}else{Ext.callback(g[c],g.scope,[a,b,d]);Ext.callback(g.callback,g.scope,[a,b,d])}}},onData:function(l,j,c){var g=this,d=0,e,k,a,b,h;if(j){k=g.createEvents(c);for(e=k.length;d<e;++d){a=k[d];b=g.getTransaction(a);g.fireEvent("data",g,a);if(b){g.runCallback(b,a,true);Ext.direct.Manager.removeTransaction(b)}}}else{h=[].concat(l.transaction);for(e=h.length;d<e;++d){b=g.getTransaction(h[d]);if(b&&b.retryCount<g.maxRetries){b.retry()}else{a=new Ext.direct.ExceptionEvent({data:null,transaction:b,code:Ext.direct.Manager.exceptions.TRANSPORT,message:"Unable to connect to the server.",xhr:c});g.fireEvent("data",g,a);if(b){g.runCallback(b,a,false);Ext.direct.Manager.removeTransaction(b)}}}}},getTransaction:function(a){return a&&a.tid?Ext.direct.Manager.getTransaction(a.tid):null},configureRequest:function(d,a,g){var h=this,c=a.getCallData(g),e=c.data,i=c.callback,j=c.scope,b;b=new Ext.direct.Transaction({provider:h,args:g,action:d,method:a.name,data:e,callback:j&&Ext.isFunction(i)?Ext.Function.bind(i,j):i});if(h.fireEvent("beforecall",h,b,a)!==false){Ext.direct.Manager.addTransaction(b);h.queueTransaction(b);h.fireEvent("call",h,b,a)}},getCallData:function(a){return{action:a.action,method:a.method,data:a.data,type:"rpc",tid:a.id}},sendRequest:function(h){var g=this,e={url:g.url,callback:g.onData,scope:g,transaction:h,timeout:g.timeout},b,d=g.enableUrlEncode,c=0,a,j;if(Ext.isArray(h)){b=[];for(a=h.length;c<a;++c){b.push(g.getCallData(h[c]))}}else{b=g.getCallData(h)}if(d){j={};j[Ext.isString(d)?d:"data"]=Ext.encode(b);e.params=j}else{e.jsonData=b}Ext.Ajax.request(e)},queueTransaction:function(c){var b=this,a=b.enableBuffer;if(c.form){b.sendFormRequest(c);return}b.callBuffer.push(c);if(a){if(!b.callTask){b.callTask=new Ext.util.DelayedTask(b.combineAndSend,b)}b.callTask.delay(Ext.isNumber(a)?a:10)}else{b.combineAndSend()}},combineAndSend:function(){var b=this.callBuffer,a=b.length;if(a>0){this.sendRequest(a==1?b[0]:b);this.callBuffer=[]}},configureFormRequest:function(e,a,b,i,j){var h=this,c=new Ext.direct.Transaction({provider:h,action:e,method:a.name,args:[b,i,j],callback:j&&Ext.isFunction(i)?Ext.Function.bind(i,j):i,isForm:true}),g,d;if(h.fireEvent("beforecall",h,c,a)!==false){Ext.direct.Manager.addTransaction(c);g=String(b.getAttribute("enctype")).toLowerCase()=="multipart/form-data";d={extTID:c.id,extAction:e,extMethod:a.name,extType:"rpc",extUpload:String(g)};Ext.apply(c,{form:Ext.getDom(b),isUpload:g,params:i&&Ext.isObject(i.params)?Ext.apply(d,i.params):d});h.fireEvent("call",h,c,a);h.sendFormRequest(c)}},sendFormRequest:function(a){Ext.Ajax.request({url:this.url,params:a.params,callback:this.onData,scope:this,form:a.form,isUpload:a.isUpload,transaction:a})}});Ext.define("Ext.draw.Matrix",{requires:["Ext.draw.Draw"],constructor:function(h,g,l,k,j,i){if(h!=null){this.matrix=[[h,l,j],[g,k,i],[0,0,1]]}else{this.matrix=[[1,0,0],[0,1,0],[0,0,1]]}},add:function(s,p,m,k,i,h){var n=this,g=[[],[],[]],r=[[s,m,i],[p,k,h],[0,0,1]],q,o,l,j;for(q=0;q<3;q++){for(o=0;o<3;o++){j=0;for(l=0;l<3;l++){j+=n.matrix[q][l]*r[l][o]}g[q][o]=j}}n.matrix=g},prepend:function(s,p,m,k,i,h){var n=this,g=[[],[],[]],r=[[s,m,i],[p,k,h],[0,0,1]],q,o,l,j;for(q=0;q<3;q++){for(o=0;o<3;o++){j=0;for(l=0;l<3;l++){j+=r[q][l]*n.matrix[l][o]}g[q][o]=j}}n.matrix=g},invert:function(){var j=this.matrix,i=j[0][0],h=j[1][0],n=j[0][1],m=j[1][1],l=j[0][2],k=j[1][2],g=i*m-h*n;return new Ext.draw.Matrix(m/g,-h/g,-n/g,i/g,(n*k-m*l)/g,(h*l-i*k)/g)},clone:function(){var i=this.matrix,h=i[0][0],g=i[1][0],m=i[0][1],l=i[1][1],k=i[0][2],j=i[1][2];return new Ext.draw.Matrix(h,g,m,l,k,j)},translate:function(a,b){this.prepend(1,0,0,1,a,b)},scale:function(b,e,a,d){var c=this;if(e==null){e=b}c.add(b,0,0,e,a*(1-b),d*(1-e))},rotate:function(c,b,h){c=Ext.draw.Draw.rad(c);var e=this,g=+Math.cos(c).toFixed(9),d=+Math.sin(c).toFixed(9);e.add(g,d,-d,g,b-g*b+d*h,-(d*b)+h-g*h)},x:function(a,c){var b=this.matrix;return a*b[0][0]+c*b[0][1]+b[0][2]},y:function(a,c){var b=this.matrix;return a*b[1][0]+c*b[1][1]+b[1][2]},get:function(b,a){return +this.matrix[b][a].toFixed(4)},toString:function(){var a=this;return[a.get(0,0),a.get(0,1),a.get(1,0),a.get(1,1),0,0].join()},toSvg:function(){var a=this;return"matrix("+[a.get(0,0),a.get(1,0),a.get(0,1),a.get(1,1),a.get(0,2),a.get(1,2)].join()+")"},toFilter:function(b,a){var c=this;b=b||0;a=a||0;return"progid:DXImageTransform.Microsoft.Matrix(sizingMethod='auto expand', filterType='bilinear', M11="+c.get(0,0)+", M12="+c.get(0,1)+", M21="+c.get(1,0)+", M22="+c.get(1,1)+", Dx="+(c.get(0,2)+b)+", Dy="+(c.get(1,2)+a)+")"},offset:function(){var a=this.matrix;return[(a[0][2]||0).toFixed(4),(a[1][2]||0).toFixed(4)]},split:function(){function d(g){return g[0]*g[0]+g[1]*g[1]}function b(g){var h=Math.sqrt(d(g));g[0]/=h;g[1]/=h}var a=this.matrix,c={translateX:a[0][2],translateY:a[1][2]},e;e=[[a[0][0],a[0][1]],[a[1][1],a[1][1]]];c.scaleX=Math.sqrt(d(e[0]));b(e[0]);c.shear=e[0][0]*e[1][0]+e[0][1]*e[1][1];e[1]=[e[1][0]-e[0][0]*c.shear,e[1][1]-e[0][1]*c.shear];c.scaleY=Math.sqrt(d(e[1]));b(e[1]);c.shear/=c.scaleY;c.rotate=Math.asin(-e[0][1]);c.isSimple=!+c.shear.toFixed(9)&&(c.scaleX.toFixed(9)==c.scaleY.toFixed(9)||!c.rotate);return c}});Ext.define("Ext.draw.SpriteDD",{extend:"Ext.dd.DragSource",constructor:function(b,a){var d=this,c=b.el;d.sprite=b;d.el=c;d.dragData={el:c,sprite:b};d.callParent([c,a]);d.sprite.setStyle("cursor","move")},showFrame:Ext.emptyFn,createFrame:Ext.emptyFn,getDragEl:function(a){return this.el},getRegion:function(){var j=this,g=j.el,m,d,c,o,n,s,a,k,h,q,p;p=j.sprite;q=p.getBBox();try{m=Ext.Element.getXY(g)}catch(i){}if(!m){return null}d=m[0];c=d+q.width;o=m[1];n=o+q.height;return new Ext.util.Region(o,c,n,d)},startDrag:function(b,d){var c=this,a=c.sprite.attr;c.prev=c.sprite.surface.transformToViewBox(b,d)},onDrag:function(i){var h=i.getXY(),g=this,d=g.sprite,a=d.attr,c,b;h=g.sprite.surface.transformToViewBox(h[0],h[1]);c=h[0]-g.prev[0];b=h[1]-g.prev[1];d.setAttributes({translate:{x:a.translation.x+c,y:a.translation.y+b}},true);g.prev=h},setDragElPos:function(){return false}});Ext.define("Ext.draw.Sprite",{mixins:{observable:"Ext.util.Observable",animate:"Ext.util.Animate"},requires:["Ext.draw.SpriteDD"],dirty:false,dirtyHidden:false,dirtyTransform:false,dirtyPath:true,dirtyFont:true,zIndexDirty:true,isSprite:true,zIndex:0,fontProperties:["font","font-size","font-weight","font-style","font-family","text-anchor","text"],pathProperties:["x","y","d","path","height","width","radius","r","rx","ry","cx","cy"],constructor:function(a){var b=this;a=Ext.merge({},a||{});b.id=Ext.id(null,"ext-sprite-");b.transformations=[];Ext.copyTo(this,a,"surface,group,type,draggable");b.bbox={};b.attr={zIndex:0,translation:{x:null,y:null},rotation:{degrees:null,x:null,y:null},scaling:{x:null,y:null,cx:null,cy:null}};delete a.surface;delete a.group;delete a.type;delete a.draggable;b.setAttributes(a);b.addEvents("beforedestroy","destroy","render","mousedown","mouseup","mouseover","mouseout","mousemove","click");b.mixins.observable.constructor.apply(this,arguments)},initDraggable:function(){var a=this;a.draggable=true;if(!a.el){a.surface.createSpriteElement(a)}a.dd=new Ext.draw.SpriteDD(a,Ext.isBoolean(a.draggable)?null:a.draggable);a.on("beforedestroy",a.dd.destroy,a.dd)},setAttributes:function(l,o){var t=this,j=t.fontProperties,q=j.length,h=t.pathProperties,g=h.length,r=!!t.surface,a=r&&t.surface.customAttributes||{},c=t.attr,b=false,m,p,k,d,s,n,u,e;l=Ext.apply({},l);for(m in a){if(l.hasOwnProperty(m)&&typeof a[m]=="function"){Ext.apply(l,a[m].apply(t,[].concat(l[m])))}}if(!!l.hidden!==!!c.hidden){t.dirtyHidden=true}for(p=0;p<g;p++){m=h[p];if(m in l&&l[m]!==c[m]){t.dirtyPath=true;b=true;break}}if("zIndex" in l){t.zIndexDirty=true}if("text" in l){t.dirtyFont=true;b=true}for(p=0;p<q;p++){m=j[p];if(m in l&&l[m]!==c[m]){t.dirtyFont=true;b=true;break}}k=l.translation||l.translate;delete l.translate;delete l.translation;d=c.translation;if(k){if(("x" in k&&k.x!==d.x)||("y" in k&&k.y!==d.y)){t.dirtyTransform=true;d.x=k.x;d.y=k.y}}s=l.rotation||l.rotate;n=c.rotation;delete l.rotate;delete l.rotation;if(s){if(("x" in s&&s.x!==n.x)||("y" in s&&s.y!==n.y)||("degrees" in s&&s.degrees!==n.degrees)){t.dirtyTransform=true;n.x=s.x;n.y=s.y;n.degrees=s.degrees}}u=l.scaling||l.scale;e=c.scaling;delete l.scale;delete l.scaling;if(u){if(("x" in u&&u.x!==e.x)||("y" in u&&u.y!==e.y)||("cx" in u&&u.cx!==e.cx)||("cy" in u&&u.cy!==e.cy)){t.dirtyTransform=true;e.x=u.x;e.y=u.y;e.cx=u.cx;e.cy=u.cy}}if(!t.dirtyTransform&&b){if(c.scaling.x===null||c.scaling.y===null||c.rotation.y===null||c.rotation.y===null){t.dirtyTransform=true}}Ext.apply(c,l);t.dirty=true;if(o===true&&r){t.redraw()}return this},getBBox:function(){return this.surface.getBBox(this)},setText:function(a){return this.surface.setText(this,a)},hide:function(a){this.setAttributes({hidden:true},a);return this},show:function(a){this.setAttributes({hidden:false},a);return this},remove:function(){if(this.surface){this.surface.remove(this);return true}return false},onRemove:function(){this.surface.onRemove(this)},destroy:function(){var a=this;if(a.fireEvent("beforedestroy",a)!==false){a.remove();a.surface.onDestroy(a);a.clearListeners();a.fireEvent("destroy")}},redraw:function(){this.surface.renderItem(this);return this},setStyle:function(){this.el.setStyle.apply(this.el,arguments);return this},addCls:function(a){this.surface.addCls(this,a);return this},removeCls:function(a){this.surface.removeCls(this,a);return this}});Ext.define("Ext.draw.Text",{extend:"Ext.draw.Component",uses:["Ext.util.CSS"],alias:"widget.text",text:"",focusable:false,viewBox:false,autoSize:true,baseCls:Ext.baseCSSPrefix+"surface "+Ext.baseCSSPrefix+"draw-text",initComponent:function(){var a=this;a.textConfig=Ext.apply({type:"text",text:a.text,rotate:{degrees:a.degrees||0}},a.textStyle);Ext.apply(a.textConfig,a.getStyles(a.styleSelectors||a.styleSelector));a.initialConfig.items=[a.textConfig];a.callParent(arguments)},getStyles:function(d){d=Ext.Array.from(d);var c=0,b=d.length,g,e,h,a={};for(;c<b;c++){g=Ext.util.CSS.getRule(d[c]);if(g){e=g.style;if(e){Ext.apply(a,{"font-family":e.fontFamily,"font-weight":e.fontWeight,"line-height":e.lineHeight,"font-size":e.fontSize,fill:e.color})}}}return a},setAngle:function(d){var c=this,a,b;if(c.rendered){a=c.surface;b=a.items.items[0];c.degrees=d;b.setAttributes({rotate:{degrees:d}},true);if(c.autoSize||c.viewBox){c.updateLayout()}}else{c.degrees=d}},setText:function(d){var c=this,a,b;if(c.rendered){a=c.surface;b=a.items.items[0];c.text=d||"";a.remove(b);c.textConfig.type="text";c.textConfig.text=c.text;b=a.add(c.textConfig);b.setAttributes({rotate:{degrees:c.degrees}},true);if(c.autoSize||c.viewBox){c.updateLayout()}}else{c.on({render:function(){c.setText(d)},single:true})}}});Ext.define("Ext.draw.engine.ImageExporter",{singleton:true,defaultUrl:"http://svg.sencha.io",supportedTypes:["image/png","image/jpeg"],widthParam:"width",heightParam:"height",typeParam:"type",svgParam:"svg",formCls:Ext.baseCSSPrefix+"hide-display",generate:function(a,b){b=b||{};var e=this,c=b.type,d;if(Ext.Array.indexOf(e.supportedTypes,c)===-1){return false}d=Ext.getBody().createChild({tag:"form",method:"POST",action:b.url||e.defaultUrl,cls:e.formCls,children:[{tag:"input",type:"hidden",name:b.widthParam||e.widthParam,value:b.width||a.width},{tag:"input",type:"hidden",name:b.heightParam||e.heightParam,value:b.height||a.height},{tag:"input",type:"hidden",name:b.typeParam||e.typeParam,value:c},{tag:"input",type:"hidden",name:b.svgParam||e.svgParam}]});d.last(null,true).value=Ext.draw.engine.SvgExporter.generate(a);d.dom.submit();d.remove();return true}});Ext.define("Ext.draw.engine.Svg",{extend:"Ext.draw.Surface",requires:["Ext.draw.Draw","Ext.draw.Sprite","Ext.draw.Matrix","Ext.Element"],engine:"Svg",trimRe:/^\s+|\s+$/g,spacesRe:/\s+/,xlink:"http://www.w3.org/1999/xlink",translateAttrs:{radius:"r",radiusX:"rx",radiusY:"ry",path:"d",lineWidth:"stroke-width",fillOpacity:"fill-opacity",strokeOpacity:"stroke-opacity",strokeLinejoin:"stroke-linejoin"},parsers:{},minDefaults:{circle:{cx:0,cy:0,r:0,fill:"none",stroke:null,"stroke-width":null,opacity:null,"fill-opacity":null,"stroke-opacity":null},ellipse:{cx:0,cy:0,rx:0,ry:0,fill:"none",stroke:null,"stroke-width":null,opacity:null,"fill-opacity":null,"stroke-opacity":null},rect:{x:0,y:0,width:0,height:0,rx:0,ry:0,fill:"none",stroke:null,"stroke-width":null,opacity:null,"fill-opacity":null,"stroke-opacity":null},text:{x:0,y:0,"text-anchor":"start","font-family":null,"font-size":null,"font-weight":null,"font-style":null,fill:"#000",stroke:null,"stroke-width":null,opacity:null,"fill-opacity":null,"stroke-opacity":null},path:{d:"M0,0",fill:"none",stroke:null,"stroke-width":null,opacity:null,"fill-opacity":null,"stroke-opacity":null},image:{x:0,y:0,width:0,height:0,preserveAspectRatio:"none",opacity:null}},createSvgElement:function(d,a){var c=this.domRef.createElementNS("http://www.w3.org/2000/svg",d),b;if(a){for(b in a){c.setAttribute(b,String(a[b]))}}return c},createSpriteElement:function(a){var b=this.createSvgElement(a.type);b.id=a.id;if(b.style){b.style.webkitTapHighlightColor="rgba(0,0,0,0)"}a.el=Ext.get(b);this.applyZIndex(a);a.matrix=new Ext.draw.Matrix();a.bbox={plain:0,transform:0};this.applyAttrs(a);this.applyTransformations(a);a.fireEvent("render",a);return b},getBBoxText:function(j){var k={},g,l,a,c,h,b;if(j&&j.el){b=j.el.dom;try{k=b.getBBox();return k}catch(d){}k={x:k.x,y:Infinity,width:0,height:0};h=b.getNumberOfChars();for(c=0;c<h;c++){g=b.getExtentOfChar(c);k.y=Math.min(g.y,k.y);l=g.y+g.height-k.y;k.height=Math.max(k.height,l);a=g.x+g.width-k.x;k.width=Math.max(k.width,a)}return k}},hide:function(){Ext.get(this.el).hide()},show:function(){Ext.get(this.el).show()},hidePrim:function(a){this.addCls(a,Ext.baseCSSPrefix+"hide-visibility")},showPrim:function(a){this.removeCls(a,Ext.baseCSSPrefix+"hide-visibility")},getDefs:function(){return this._defs||(this._defs=this.createSvgElement("defs"))},transform:function(k,a){var h=this,j=new Ext.draw.Matrix(),e=k.transformations,d=e.length,c=0,b,g;for(;c<d;c++){b=e[c];g=b.type;if(g=="translate"){j.translate(b.x,b.y)}else{if(g=="rotate"){j.rotate(b.degrees,b.x,b.y)}else{if(g=="scale"){j.scale(b.x,b.y,b.centerX,b.centerY)}}}}k.matrix=j;if(!a){k.el.set({transform:j.toSvg()})}},setSize:function(c,a){var d=this,b=d.el;c=+c||d.width;a=+a||d.height;d.width=c;d.height=a;b.setSize(c,a);b.set({width:c,height:a});d.callParent([c,a])},getRegion:function(){var e=this.el.getXY(),c=this.bgRect.getXY(),b=Math.max,a=b(e[0],c[0]),d=b(e[1],c[1]);return{left:a,top:d,right:a+this.width,bottom:d+this.height}},onRemove:function(a){if(a.el){a.el.destroy();delete a.el}this.callParent(arguments)},setViewBox:function(b,d,c,a){if(isFinite(b)&&isFinite(d)&&isFinite(c)&&isFinite(a)){this.callParent(arguments);this.el.dom.setAttribute("viewBox",[b,d,c,a].join(" "))}},render:function(c){var g=this,e,b,d,a,h,i;if(!g.el){e=g.width||0;b=g.height||0;d=g.createSvgElement("svg",{xmlns:"http://www.w3.org/2000/svg",version:1.1,width:e,height:b});a=g.getDefs();h=g.createSvgElement("rect",{width:"100%",height:"100%",fill:"#000",stroke:"none",opacity:0});if(Ext.isSafari3){i=g.createSvgElement("rect",{x:-10,y:-10,width:"110%",height:"110%",fill:"none",stroke:"#000"})}d.appendChild(a);if(Ext.isSafari3){d.appendChild(i)}d.appendChild(h);c.appendChild(d);g.el=Ext.get(d);g.bgRect=Ext.get(h);if(Ext.isSafari3){g.webkitRect=Ext.get(i);g.webkitRect.hide()}g.el.on({scope:g,mouseup:g.onMouseUp,mousedown:g.onMouseDown,mouseover:g.onMouseOver,mouseout:g.onMouseOut,mousemove:g.onMouseMove,mouseenter:g.onMouseEnter,mouseleave:g.onMouseLeave,click:g.onClick,dblclick:g.onDblClick})}g.renderAll()},onMouseEnter:function(a){if(this.el.parent().getRegion().contains(a.getPoint())){this.fireEvent("mouseenter",a)}},onMouseLeave:function(a){if(!this.el.parent().getRegion().contains(a.getPoint())){this.fireEvent("mouseleave",a)}},processEvent:function(b,g){var d=g.getTarget(),a=this.surface,c;this.fireEvent(b,g);if(d.nodeName=="tspan"&&d.parentNode){d=d.parentNode}c=this.items.get(d.id);if(c){c.fireEvent(b,c,g)}},tuneText:function(k,l){var a=k.el.dom,b=[],n,h,m,d,e,c,g,j;if(l.hasOwnProperty("text")){m=k.tspans&&Ext.Array.map(k.tspans,function(i){return i.textContent}).join("");if(!k.tspans||l.text!=m){b=this.setText(k,l.text);k.tspans=b}else{b=k.tspans||[]}}if(b.length){n=this.getBBoxText(k).height;j=k.el.dom.getAttribute("x");for(d=0,e=b.length;d<e;d++){g=(Ext.isFF3_0||Ext.isFF3_5)?2:4;b[d].setAttribute("x",j);b[d].setAttribute("dy",d?n*1.2:n/g)}k.dirty=true}},setText:function(k,d){var h=this,a=k.el.dom,b=[],m,j,l,e,g,c;while(a.firstChild){a.removeChild(a.firstChild)}c=String(d).split("\n");for(e=0,g=c.length;e<g;e++){l=c[e];if(l){j=h.createSvgElement("tspan");j.appendChild(document.createTextNode(Ext.htmlDecode(l)));a.appendChild(j);b[e]=j}}return b},renderAll:function(){this.items.each(this.renderItem,this)},renderItem:function(a){if(!this.el){return}if(!a.el){this.createSpriteElement(a)}if(a.zIndexDirty){this.applyZIndex(a)}if(a.dirty){this.applyAttrs(a);if(a.dirtyTransform){this.applyTransformations(a)}}},redraw:function(a){a.dirty=a.zIndexDirty=true;this.renderItem(a)},applyAttrs:function(r){var m=this,c=r.el,q=r.group,j=r.attr,s=m.parsers,g=m.gradientsMap||{},k=Ext.isSafari&&!Ext.isStrict,e,h,l,p,d,o,b,a,n;if(q){e=[].concat(q);l=e.length;for(h=0;h<l;h++){q=e[h];m.getGroup(q).add(r)}delete r.group}p=m.scrubAttrs(r)||{};r.bbox.plain=0;r.bbox.transform=0;if(r.type=="circle"||r.type=="ellipse"){p.cx=p.cx||p.x;p.cy=p.cy||p.y}else{if(r.type=="rect"){p.rx=p.ry=p.r}else{if(r.type=="path"&&p.d){p.d=Ext.draw.Draw.pathToString(Ext.draw.Draw.pathToAbsolute(p.d))}}}r.dirtyPath=false;if(p["clip-rect"]){m.setClip(r,p);delete p["clip-rect"]}if(r.type=="text"&&p.font&&r.dirtyFont){c.set({style:"font: "+p.font})}if(r.type=="image"){c.dom.setAttributeNS(m.xlink,"href",p.src)}Ext.applyIf(p,m.minDefaults[r.type]);if(r.dirtyHidden){(j.hidden)?m.hidePrim(r):m.showPrim(r);r.dirtyHidden=false}for(o in p){if(p.hasOwnProperty(o)&&p[o]!=null){if(k&&("color|stroke|fill".indexOf(o)>-1)&&(p[o] in g)){p[o]=g[p[o]]}if(o=="hidden"&&r.type=="text"){continue}if(o in s){c.dom.setAttribute(o,s[o](p[o],r,m))}else{c.dom.setAttribute(o,p[o])}}}if(r.type=="text"){m.tuneText(r,p)}r.dirtyFont=false;b=j.style;if(b){c.setStyle(b)}r.dirty=false;if(Ext.isSafari3){m.webkitRect.show();setTimeout(function(){m.webkitRect.hide()})}},setClip:function(b,g){var e=this,d=g["clip-rect"],a,c;if(d){if(b.clip){b.clip.parentNode.parentNode.removeChild(b.clip.parentNode)}a=e.createSvgElement("clipPath");c=e.createSvgElement("rect");a.id=Ext.id(null,"ext-clip-");c.setAttribute("x",d.x);c.setAttribute("y",d.y);c.setAttribute("width",d.width);c.setAttribute("height",d.height);a.appendChild(c);e.getDefs().appendChild(a);b.el.dom.setAttribute("clip-path","url(#"+a.id+")");b.clip=c}},applyZIndex:function(d){var g=this,b=g.items,a=b.indexOf(d),e=d.el,c;if(g.el.dom.childNodes[a+2]!==e.dom){if(a>0){do{c=b.getAt(--a).el}while(!c&&a>0)}e.insertAfter(c||g.bgRect)}d.zIndexDirty=false},createItem:function(a){var b=new Ext.draw.Sprite(a);b.surface=this;return b},addGradient:function(h){h=Ext.draw.Draw.parseGradient(h);var e=this,d=h.stops.length,a=h.vector,l=Ext.isSafari&&!Ext.isStrict,j,g,k,c,b;b=e.gradientsMap||{};if(!l){if(h.type=="linear"){j=e.createSvgElement("linearGradient");j.setAttribute("x1",a[0]);j.setAttribute("y1",a[1]);j.setAttribute("x2",a[2]);j.setAttribute("y2",a[3])}else{j=e.createSvgElement("radialGradient");j.setAttribute("cx",h.centerX);j.setAttribute("cy",h.centerY);j.setAttribute("r",h.radius);if(Ext.isNumber(h.focalX)&&Ext.isNumber(h.focalY)){j.setAttribute("fx",h.focalX);j.setAttribute("fy",h.focalY)}}j.id=h.id;e.getDefs().appendChild(j);for(c=0;c<d;c++){g=h.stops[c];k=e.createSvgElement("stop");k.setAttribute("offset",g.offset+"%");k.setAttribute("stop-color",g.color);k.setAttribute("stop-opacity",g.opacity);j.appendChild(k)}}else{b["url(#"+h.id+")"]=h.stops[0].color}e.gradientsMap=b},hasCls:function(a,b){return b&&(" "+(a.el.dom.getAttribute("class")||"")+" ").indexOf(" "+b+" ")!=-1},addCls:function(e,h){var g=e.el,d,a,c,b=[],j=g.getAttribute("class")||"";if(!Ext.isArray(h)){if(typeof h=="string"&&!this.hasCls(e,h)){g.set({"class":j+" "+h})}}else{for(d=0,a=h.length;d<a;d++){c=h[d];if(typeof c=="string"&&(" "+j+" ").indexOf(" "+c+" ")==-1){b.push(c)}}if(b.length){g.set({"class":" "+b.join(" ")})}}},removeCls:function(k,g){var h=this,b=k.el,d=b.getAttribute("class")||"",c,j,e,l,a;if(!Ext.isArray(g)){g=[g]}if(d){a=d.replace(h.trimRe," ").split(h.spacesRe);for(c=0,e=g.length;c<e;c++){l=g[c];if(typeof l=="string"){l=l.replace(h.trimRe,"");j=Ext.Array.indexOf(a,l);if(j!=-1){Ext.Array.erase(a,j,1)}}}b.set({"class":a.join(" ")})}},destroy:function(){var a=this;a.callParent();if(a.el){a.el.remove()}if(a._defs){Ext.get(a._defs).destroy()}if(a.bgRect){Ext.get(a.bgRect).destroy()}if(a.webkitRect){Ext.get(a.webkitRect).destroy()}delete a.el}});Ext.define("Ext.draw.engine.SvgExporter",function(){var b=/,/g,c=/(-?\d*\.?\d*){1}(em|ex|px|in|cm|mm|pt|pc|%)\s('*.*'*)/,j=/rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)/g,h=/rgba\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,([\d\.]+)\)/g,g,i,e,m,n=function(o){g=o;i=g.length;e=g.width;m=g.height},k={path:function(s){var o=s.attr,v=o.path,r="",t,u,q;if(Ext.isArray(v[0])){q=v.length;for(u=0;u<q;u++){r+=v[u].join(" ")}}else{if(Ext.isArray(v)){r=v.join(" ")}else{r=v.replace(b," ")}}t=d({d:r,fill:o.fill||"none",stroke:o.stroke,"fill-opacity":o.opacity,"stroke-width":o["stroke-width"],"stroke-opacity":o["stroke-opacity"],"z-index":o.zIndex,transform:s.matrix.toSvg()});return"<path "+t+"/>"},text:function(u){var r=u.attr,q=c.exec(r.font),w=(q&&q[1])||"12",p=(q&&q[3])||"Arial",v=r.text,t=(Ext.isFF3_0||Ext.isFF3_5)?2:4,o="",s;u.getBBox();o+='<tspan x="'+(r.x||"")+'" dy="';o+=(w/t)+'">';o+=Ext.htmlEncode(v)+"</tspan>";s=d({x:r.x,y:r.y,"font-size":w,"font-family":p,"font-weight":r["font-weight"],"text-anchor":r["text-anchor"],fill:r.fill||"#000","fill-opacity":r.opacity,transform:u.matrix.toSvg()});return"<text "+s+">"+o+"</text>"},rect:function(p){var o=p.attr,q=d({x:o.x,y:o.y,rx:o.rx,ry:o.ry,width:o.width,height:o.height,fill:o.fill||"none","fill-opacity":o.opacity,stroke:o.stroke,"stroke-opacity":o["stroke-opacity"],"stroke-width":o["stroke-width"],transform:p.matrix&&p.matrix.toSvg()});return"<rect "+q+"/>"},circle:function(p){var o=p.attr,q=d({cx:o.x,cy:o.y,r:o.radius,fill:o.translation.fill||o.fill||"none","fill-opacity":o.opacity,stroke:o.stroke,"stroke-opacity":o["stroke-opacity"],"stroke-width":o["stroke-width"],transform:p.matrix.toSvg()});return"<circle "+q+" />"},image:function(p){var o=p.attr,q=d({x:o.x-(o.width/2>>0),y:o.y-(o.height/2>>0),width:o.width,height:o.height,"xlink:href":o.src,transform:p.matrix.toSvg()});return"<image "+q+" />"}},a=function(){var o='<?xml version="1.0" standalone="yes"?>';o+='<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">';return o},l=function(){var w='<svg width="'+e+'px" height="'+m+'px" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1">',p="",H,F,v,q,G,J,z,x,t,y,B,o,K,u,E,C,I,D,s,r;v=g.items.items;F=v.length;G=function(O){var V=O.childNodes,S=V.length,R=0,P,Q,L="",M,U,N,T;for(;R<S;R++){M=V[R];U=M.attributes;N=M.tagName;L+="<"+N;for(Q=0,P=U.length;Q<P;Q++){T=U.item(Q);L+=" "+T.name+'="'+T.value+'"'}L+=">";if(M.childNodes.length>0){L+=G(M)}L+="</"+N+">"}return L};if(g.getDefs){p=G(g.getDefs())}else{x=g.gradientsColl;if(x){t=x.keys;y=x.items;B=0;o=t.length}for(;B<o;B++){K=t[B];u=y[B];q=g.gradientsColl.getByKey(K);p+='<linearGradient id="'+K+'" x1="0" y1="0" x2="1" y2="1">';var A=q.colors.replace(j,"rgb($1|$2|$3)");A=A.replace(h,"rgba($1|$2|$3|$4)");J=A.split(",");for(E=0,I=J.length;E<I;E++){z=J[E].split(" ");A=Ext.draw.Color.fromString(z[1].replace(/\|/g,","));p+='<stop offset="'+z[0]+'" stop-color="'+A.toString()+'" stop-opacity="1"></stop>'}p+="</linearGradient>"}}w+="<defs>"+p+"</defs>";w+=k.rect({attr:{width:"100%",height:"100%",fill:"#fff",stroke:"none",opacity:"0"}});D=new Array(F);for(E=0;E<F;E++){D[E]=E}D.sort(function(M,L){s=v[M].attr.zIndex||0;r=v[L].attr.zIndex||0;if(s==r){return M-L}return s-r});for(E=0;E<F;E++){H=v[D[E]];if(!H.attr.hidden){w+=k[H.type](H)}}w+="</svg>";return w},d=function(q){var p="",o;for(o in q){if(q.hasOwnProperty(o)&&q[o]!=null){p+=o+'="'+q[o]+'" '}}return p};return{singleton:true,generate:function(o,p){p=p||{};n(o);return a()+l()}}});Ext.define("Ext.draw.engine.Vml",{extend:"Ext.draw.Surface",requires:["Ext.draw.Draw","Ext.draw.Color","Ext.draw.Sprite","Ext.draw.Matrix","Ext.Element"],engine:"Vml",map:{M:"m",L:"l",C:"c",Z:"x",m:"t",l:"r",c:"v",z:"x"},bitesRe:/([clmz]),?([^clmz]*)/gi,valRe:/-?[^,\s\-]+/g,fillUrlRe:/^url\(\s*['"]?([^\)]+?)['"]?\s*\)$/i,pathlike:/^(path|rect)$/,NonVmlPathRe:/[ahqstv]/ig,partialPathRe:/[clmz]/g,fontFamilyRe:/^['"]+|['"]+$/g,baseVmlCls:Ext.baseCSSPrefix+"vml-base",vmlGroupCls:Ext.baseCSSPrefix+"vml-group",spriteCls:Ext.baseCSSPrefix+"vml-sprite",measureSpanCls:Ext.baseCSSPrefix+"vml-measure-span",zoom:21600,coordsize:1000,coordorigin:"0 0",zIndexShift:0,orderSpritesByZIndex:false,path2vml:function(t){var n=this,u=n.NonVmlPathRe,b=n.map,e=n.valRe,s=n.zoom,d=n.bitesRe,g=Ext.Function.bind(Ext.draw.Draw.pathToAbsolute,Ext.draw.Draw),m,o,c,a,k,q,h,l;if(String(t).match(u)){g=Ext.Function.bind(Ext.draw.Draw.path2curve,Ext.draw.Draw)}else{if(!String(t).match(n.partialPathRe)){m=String(t).replace(d,function(r,w,j){var v=[],i=w.toLowerCase()=="m",p=b[w];j.replace(e,function(x){if(i&&v.length===2){p+=v+b[w=="m"?"l":"L"];v=[]}v.push(Math.round(x*s))});return p+v});return m}}o=g(t);m=[];for(k=0,q=o.length;k<q;k++){c=o[k];a=o[k][0].toLowerCase();if(a=="z"){a="x"}for(h=1,l=c.length;h<l;h++){a+=Math.round(c[h]*n.zoom)+(h!=l-1?",":"")}m.push(a)}return m.join(" ")},translateAttrs:{radius:"r",radiusX:"rx",radiusY:"ry",lineWidth:"stroke-width",fillOpacity:"fill-opacity",strokeOpacity:"stroke-opacity",strokeLinejoin:"stroke-linejoin"},minDefaults:{circle:{fill:"none",stroke:null,"stroke-width":null,opacity:null,"fill-opacity":null,"stroke-opacity":null},ellipse:{cx:0,cy:0,rx:0,ry:0,fill:"none",stroke:null,"stroke-width":null,opacity:null,"fill-opacity":null,"stroke-opacity":null},rect:{x:0,y:0,width:0,height:0,rx:0,ry:0,fill:"none",stroke:null,"stroke-width":null,opacity:null,"fill-opacity":null,"stroke-opacity":null},text:{x:0,y:0,"text-anchor":"start",font:'10px "Arial"',fill:"#000",stroke:null,"stroke-width":null,opacity:null,"fill-opacity":null,"stroke-opacity":null},path:{d:"M0,0",fill:"none",stroke:null,"stroke-width":null,opacity:null,"fill-opacity":null,"stroke-opacity":null},image:{x:0,y:0,width:0,height:0,preserveAspectRatio:"none",opacity:null}},onMouseEnter:function(a){this.fireEvent("mouseenter",a)},onMouseLeave:function(a){this.fireEvent("mouseleave",a)},processEvent:function(b,g){var d=g.getTarget(),a=this.surface,c;this.fireEvent(b,g);c=this.items.get(d.id);if(c){c.fireEvent(b,c,g)}},createSpriteElement:function(h){var e=this,d=h.attr,g=h.type,j=e.zoom,b=h.vml||(h.vml={}),k=Math.round,c=(g==="image")?e.createNode("image"):e.createNode("shape"),l,i,a;c.coordsize=j+" "+j;c.coordorigin=d.coordorigin||"0 0";Ext.get(c).addCls(e.spriteCls);if(g=="text"){b.path=l=e.createNode("path");l.textpathok=true;b.textpath=a=e.createNode("textpath");a.on=true;c.appendChild(a);c.appendChild(l)}c.id=h.id;h.el=Ext.get(c);h.el.setStyle("zIndex",-e.zIndexShift);e.el.appendChild(c);if(g!=="image"){i=e.createNode("skew");i.on=true;c.appendChild(i);h.skew=i}h.matrix=new Ext.draw.Matrix();h.bbox={plain:null,transform:null};this.applyAttrs(h);this.applyTransformations(h);h.fireEvent("render",h);return h.el},getBBoxText:function(b){var a=b.vml;return{x:a.X+(a.bbx||0)-a.W/2,y:a.Y-a.H/2,width:a.W,height:a.H}},applyAttrs:function(m){var s=this,c=m.vml,j=m.group,a=m.attr,b=m.el,o=b.dom,p,u,r,n,k,q,l,t,e,d,h,g;if(j){r=[].concat(j);k=r.length;for(n=0;n<k;n++){j=r[n];s.getGroup(j).add(m)}delete m.group}q=s.scrubAttrs(m)||{};if(m.zIndexDirty){s.setZIndex(m)}Ext.applyIf(q,s.minDefaults[m.type]);if(m.type=="image"){Ext.apply(m.attr,{x:q.x,y:q.y,width:q.width,height:q.height});b.setStyle({width:q.width+"px",height:q.height+"px"});o.src=q.src}if(o.href){o.href=q.href}if(o.title){o.title=q.title}if(o.target){o.target=q.target}if(o.cursor){o.cursor=q.cursor}if(m.dirtyHidden){(q.hidden)?s.hidePrim(m):s.showPrim(m);m.dirtyHidden=false}if(m.dirtyPath){if(m.type=="circle"||m.type=="ellipse"){e=q.x;d=q.y;h=q.rx||q.r||0;g=q.ry||q.r||0;o.path=Ext.String.format("ar{0},{1},{2},{3},{4},{1},{4},{1}",Math.round((e-h)*s.zoom),Math.round((d-g)*s.zoom),Math.round((e+h)*s.zoom),Math.round((d+g)*s.zoom),Math.round(e*s.zoom));m.dirtyPath=false}else{if(m.type!=="text"&&m.type!=="image"){m.attr.path=q.path=s.setPaths(m,q)||q.path;o.path=s.path2vml(q.path);m.dirtyPath=false}}}if("clip-rect" in q){s.setClip(m,q)}if(m.type=="text"){s.setTextAttributes(m,q)}if(q.opacity||q["stroke-opacity"]||q.fill){s.setFill(m,q)}if(q.stroke||q["stroke-opacity"]||q.fill){s.setStroke(m,q)}p=a.style;if(p){b.setStyle(p)}m.dirty=false},setZIndex:function(e){var h=this,j=e.attr.zIndex,b=h.zIndexShift,c,a,g,d;if(j<b){c=h.items.items;a=c.length;for(d=0;d<a;d++){if((j=c[d].attr.zIndex)&&j<b){b=j}}h.zIndexShift=b;for(d=0;d<a;d++){g=c[d];if(g.el){g.el.setStyle("zIndex",g.attr.zIndex-b)}g.zIndexDirty=false}}else{if(e.el){e.el.setStyle("zIndex",j-b);e.zIndexDirty=false}}},setPaths:function(c,d){var a=c.attr,b=c.attr["stroke-width"]||1;c.bbox.plain=null;c.bbox.transform=null;if(c.type=="circle"){a.rx=a.ry=d.r;return Ext.draw.Draw.ellipsePath(c)}else{if(c.type=="ellipse"){a.rx=d.rx;a.ry=d.ry;return Ext.draw.Draw.ellipsePath(c)}else{if(c.type=="rect"){a.rx=a.ry=d.r;return Ext.draw.Draw.rectPath(c)}else{if(c.type=="path"&&a.path){return Ext.draw.Draw.pathToAbsolute(a.path)}}}}return false},setFill:function(k,e){var h=this,c=k.el.dom,j=c.fill,b=false,g,i,a,l,d;if(!j){j=c.fill=h.createNode("fill");b=true}if(Ext.isArray(e.fill)){e.fill=e.fill[0]}if(e.fill=="none"){j.on=false}else{if(typeof e.opacity=="number"){j.opacity=e.opacity}if(typeof e["fill-opacity"]=="number"){j.opacity=e["fill-opacity"]}j.on=true;if(typeof e.fill=="string"){a=e.fill.match(h.fillUrlRe);if(a){a=a[1];if(a.charAt(0)=="#"){i=h.gradientsColl.getByKey(a.substring(1))}if(i){l=e.rotation;d=-(i.angle+270+(l?l.degrees:0))%360;if(d===0){d=180}j.angle=d;j.type="gradient";j.method="sigma";if(j.colors){j.colors.value=i.colors}else{j.colors=i.colors}}else{j.src=a;j.type="tile"}}else{j.color=Ext.draw.Color.toHex(e.fill);j.src="";j.type="solid"}}}if(b){c.appendChild(j)}},setStroke:function(b,h){var e=this,d=b.el.dom,i=b.strokeEl,g=false,c,a;if(!i){i=b.strokeEl=e.createNode("stroke");g=true}if(Ext.isArray(h.stroke)){h.stroke=h.stroke[0]}if(!h.stroke||h.stroke=="none"||h.stroke==0||h["stroke-width"]==0){i.on=false}else{i.on=true;if(h.stroke&&!h.stroke.match(e.fillUrlRe)){i.color=Ext.draw.Color.toHex(h.stroke)}i.dashstyle=h["stroke-dasharray"]?"dash":"solid";i.joinstyle=h["stroke-linejoin"];i.endcap=h["stroke-linecap"]||"round";i.miterlimit=h["stroke-miterlimit"]||8;c=parseFloat(h["stroke-width"]||1)*0.75;a=h["stroke-opacity"]||1;if(Ext.isNumber(c)&&c<1){i.weight=1;i.opacity=a*c}else{i.weight=c;i.opacity=a}}if(g){d.appendChild(i)}},setClip:function(b,g){var e=this,c=b.el,a=b.clipEl,d=String(g["clip-rect"]).split(e.separatorRe);if(!a){a=b.clipEl=e.el.insertFirst(Ext.getDoc().dom.createElement("div"));a.addCls(Ext.baseCSSPrefix+"vml-sprite")}if(d.length==4){d[2]=+d[2]+(+d[0]);d[3]=+d[3]+(+d[1]);a.setStyle("clip",Ext.String.format("rect({1}px {2}px {3}px {0}px)",d[0],d[1],d[2],d[3]));a.setSize(e.el.width,e.el.height)}else{a.setStyle("clip","")}},setTextAttributes:function(i,c){var h=this,a=i.vml,e=a.textpath.style,g=h.span.style,j=h.zoom,k=Math.round,l={fontSize:"font-size",fontWeight:"font-weight",fontStyle:"font-style"},b,d;if(i.dirtyFont){if(c.font){e.font=g.font=c.font}if(c["font-family"]){e.fontFamily='"'+c["font-family"].split(",")[0].replace(h.fontFamilyRe,"")+'"';g.fontFamily=c["font-family"]}for(b in l){d=c[l[b]];if(d){e[b]=g[b]=d}}h.setText(i,c.text);if(a.textpath.string){h.span.innerHTML=String(a.textpath.string).replace(/</g,"&#60;").replace(/&/g,"&#38;").replace(/\n/g,"<br/>")}a.W=h.span.offsetWidth;a.H=h.span.offsetHeight+2;if(c["text-anchor"]=="middle"){e["v-text-align"]="center"}else{if(c["text-anchor"]=="end"){e["v-text-align"]="right";a.bbx=-Math.round(a.W/2)}else{e["v-text-align"]="left";a.bbx=Math.round(a.W/2)}}}a.X=c.x;a.Y=c.y;a.path.v=Ext.String.format("m{0},{1}l{2},{1}",Math.round(a.X*j),Math.round(a.Y*j),Math.round(a.X*j)+1);i.bbox.plain=null;i.bbox.transform=null;i.dirtyFont=false},setText:function(a,b){a.vml.textpath.string=Ext.htmlDecode(b)},hide:function(){this.el.hide()},show:function(){this.el.show()},hidePrim:function(a){a.el.addCls(Ext.baseCSSPrefix+"hide-visibility")},showPrim:function(a){a.el.removeCls(Ext.baseCSSPrefix+"hide-visibility")},setSize:function(b,a){var c=this;b=b||c.width;a=a||c.height;c.width=b;c.height=a;if(c.el){if(b!=undefined){c.el.setWidth(b)}if(a!=undefined){c.el.setHeight(a)}}c.callParent(arguments)},applyViewBox:function(){var g=this,h=g.viewBox,e=g.width,b=g.height,c,a,d;g.callParent();if(h&&(e||b)){c=g.items.items;a=c.length;for(d=0;d<a;d++){g.applyTransformations(c[d])}}},onAdd:function(a){this.callParent(arguments);if(this.el){this.renderItem(a)}},onRemove:function(a){if(a.el){a.el.remove();delete a.el}this.callParent(arguments)},render:function(a){var c=this,g=Ext.getDoc().dom,b;if(!c.createNode){try{if(!g.namespaces.rvml){g.namespaces.add("rvml","urn:schemas-microsoft-com:vml")}c.createNode=function(e){return g.createElement("<rvml:"+e+' class="rvml">')}}catch(d){c.createNode=function(e){return g.createElement("<"+e+' xmlns="urn:schemas-microsoft.com:vml" class="rvml">')}}}if(!c.el){b=g.createElement("div");c.el=Ext.get(b);c.el.addCls(c.baseVmlCls);c.span=g.createElement("span");Ext.get(c.span).addCls(c.measureSpanCls);b.appendChild(c.span);c.el.setSize(c.width||0,c.height||0);a.appendChild(b);c.el.on({scope:c,mouseup:c.onMouseUp,mousedown:c.onMouseDown,mouseover:c.onMouseOver,mouseout:c.onMouseOut,mousemove:c.onMouseMove,mouseenter:c.onMouseEnter,mouseleave:c.onMouseLeave,click:c.onClick,dblclick:c.onDblClick})}c.renderAll()},renderAll:function(){this.items.each(this.renderItem,this)},redraw:function(a){a.dirty=true;this.renderItem(a)},renderItem:function(a){if(!this.el){return}if(!a.el){this.createSpriteElement(a)}if(a.dirty){this.applyAttrs(a);if(a.dirtyTransform){this.applyTransformations(a)}}},rotationCompensation:function(d,c,a){var b=new Ext.draw.Matrix();b.rotate(-d,0.5,0.5);return{x:b.x(c,a),y:b.y(c,a)}},transform:function(x,I){var H=this,b=H.getBBox(x,true),j=b.x+b.width*0.5,h=b.y+b.height*0.5,B=new Ext.draw.Matrix(),q=x.transformations,v=q.length,C=0,o=0,d=1,c=1,n="",g=x.el,E=g.dom,z=E.style,a=H.zoom,k=x.skew,D=H.viewBoxShift,G,F,s,l,r,p,A,w,u,t,e,m;for(;C<v;C++){s=q[C];l=s.type;if(l=="translate"){B.translate(s.x,s.y)}else{if(l=="rotate"){B.rotate(s.degrees,s.x,s.y);o+=s.degrees}else{if(l=="scale"){B.scale(s.x,s.y,s.centerX,s.centerY);d*=s.x;c*=s.y}}}}x.matrix=B.clone();if(I){return}if(D){B.prepend(D.scale,0,0,D.scale,D.dx*D.scale,D.dy*D.scale)}if(x.type!="image"&&k){k.origin="0,0";k.matrix=B.toString();m=B.offset();if(m[0]>32767){m[0]=32767}else{if(m[0]<-32768){m[0]=-32768}}if(m[1]>32767){m[1]=32767}else{if(m[1]<-32768){m[1]=-32768}}k.offset=m}else{z.filter=B.toFilter();z.left=Math.min(B.x(b.x,b.y),B.x(b.x+b.width,b.y),B.x(b.x,b.y+b.height),B.x(b.x+b.width,b.y+b.height))+"px";z.top=Math.min(B.y(b.x,b.y),B.y(b.x+b.width,b.y),B.y(b.x,b.y+b.height),B.y(b.x+b.width,b.y+b.height))+"px"}},createItem:function(a){return Ext.create("Ext.draw.Sprite",a)},getRegion:function(){return this.el.getRegion()},addCls:function(a,b){if(a&&a.el){a.el.addCls(b)}},removeCls:function(a,b){if(a&&a.el){a.el.removeCls(b)}},addGradient:function(g){var d=this.gradientsColl||(this.gradientsColl=Ext.create("Ext.util.MixedCollection")),a=[],j=Ext.create("Ext.util.MixedCollection"),l,e,b,h,k,c;j.addAll(g.stops);j.sortByKey("ASC",function(m,i){m=parseInt(m,10);i=parseInt(i,10);return m>i?1:(m<i?-1:0)});l=j.keys;e=j.items;b=l.length;for(c=0;c<b;c++){h=l[c];k=e[c];a.push(h+"% "+k.color)}d.add(g.id,{colors:a.join(","),angle:g.angle})},destroy:function(){var a=this;a.callParent(arguments);if(a.el){a.el.remove()}delete a.el}});Ext.define("Ext.flash.Component",{extend:"Ext.Component",alternateClassName:"Ext.FlashComponent",alias:"widget.flash",flashVersion:"9.0.115",backgroundColor:"#ffffff",wmode:"opaque",swfWidth:"100%",swfHeight:"100%",expressInstall:false,renderTpl:['<div id="{swfId}"></div>'],initComponent:function(){this.callParent();this.addEvents("success","failure")},beforeRender:function(){this.callParent();Ext.applyIf(this.renderData,{swfId:this.getSwfId()})},afterRender:function(){var b=this,a=Ext.apply({},b.flashParams),c=Ext.apply({},b.flashVars);b.callParent();a=Ext.apply({allowScriptAccess:"always",bgcolor:b.backgroundColor,wmode:b.wmode},a);c=Ext.apply({allowedDomain:document.location.hostname},c);new swfobject.embedSWF(b.url,b.getSwfId(),b.swfWidth,b.swfHeight,b.flashVersion,b.expressInstall?b.statics.EXPRESS_INSTALL_URL:undefined,c,a,b.flashAttributes,Ext.bind(b.swfCallback,b))},swfCallback:function(b){var a=this;if(b.success){a.swf=Ext.get(b.ref);a.onSuccess();a.fireEvent("success",a)}else{a.onFailure();a.fireEvent("failure",a)}},getSwfId:function(){return this.swfId||(this.swfId="extswf"+this.getAutoId())},onSuccess:function(){this.swf.setStyle("visibility","inherit")},onFailure:Ext.emptyFn,beforeDestroy:function(){var b=this,a=b.swf;if(a){swfobject.removeSWF(b.getSwfId());Ext.destroy(a);delete b.swf}b.callParent()},statics:{EXPRESS_INSTALL_URL:"http://swfobject.googlecode.com/svn/trunk/swfobject/expressInstall.swf"}});Ext.define("Ext.form.action.Action",{alternateClassName:"Ext.form.Action",submitEmptyText:true,constructor:function(a){if(a){Ext.apply(this,a)}var b=a.params;if(Ext.isString(b)){this.params=Ext.Object.fromQueryString(b)}},run:Ext.emptyFn,onFailure:function(a){this.response=a;this.failureType=Ext.form.action.Action.CONNECT_FAILURE;this.form.afterAction(this,false)},processResponse:function(a){this.response=a;if(!a.responseText&&!a.responseXML){return true}return(this.result=this.handleResponse(a))},getUrl:function(){return this.url||this.form.url},getMethod:function(){return(this.method||this.form.method||"POST").toUpperCase()},getParams:function(){return Ext.apply({},this.params,this.form.baseParams)},createCallback:function(){var c=this,a,b=c.form;return{success:c.onSuccess,failure:c.onFailure,scope:c,timeout:(this.timeout*1000)||(b.timeout*1000),upload:b.fileUpload?c.onSuccess:a}},statics:{CLIENT_INVALID:"client",SERVER_INVALID:"server",CONNECT_FAILURE:"connect",LOAD_FAILURE:"load"}});Ext.define("Ext.form.action.Load",{extend:"Ext.form.action.Action",requires:["Ext.data.Connection"],alternateClassName:"Ext.form.Action.Load",alias:"formaction.load",type:"load",run:function(){Ext.Ajax.request(Ext.apply(this.createCallback(),{method:this.getMethod(),url:this.getUrl(),headers:this.headers,params:this.getParams()}))},onSuccess:function(b){var a=this.processResponse(b),c=this.form;if(a===true||!a.success||!a.data){this.failureType=Ext.form.action.Action.LOAD_FAILURE;c.afterAction(this,false);return}c.clearInvalid();c.setValues(a.data);c.afterAction(this,true)},handleResponse:function(c){var a=this.form.reader,b,d;if(a){b=a.read(c);d=b.records&&b.records[0]?b.records[0].data:null;return{success:b.success,data:d}}return Ext.decode(c.responseText)}});Ext.define("Ext.form.action.Submit",{extend:"Ext.form.action.Action",alternateClassName:"Ext.form.Action.Submit",alias:"formaction.submit",type:"submit",run:function(){var a=this.form;if(this.clientValidation===false||a.isValid()){this.doSubmit()}else{this.failureType=Ext.form.action.Action.CLIENT_INVALID;a.afterAction(this,false)}},doSubmit:function(){var b,a=Ext.apply(this.createCallback(),{url:this.getUrl(),method:this.getMethod(),headers:this.headers});if(this.form.hasUpload()){b=a.form=this.buildForm();a.isUpload=true}else{a.params=this.getParams()}Ext.Ajax.request(a);if(b){Ext.removeNode(b)}},getParams:function(){var c=false,b=this.callParent(),a=this.form.getValues(c,c,this.submitEmptyText!==c);return Ext.apply({},a,b)},buildForm:function(){var k=[],i,q,e=this.form,d=this.getParams(),c=[],g=e.getFields().items,h,r=g.length,j,o,m,n,l,p,b;for(h=0;h<r;h++){j=g[h];if(j.isFileUpload()){c.push(j)}}function a(s,t){k.push({tag:"input",type:"hidden",name:s,value:Ext.String.htmlEncode(t)})}for(o in d){if(d.hasOwnProperty(o)){m=d[o];if(Ext.isArray(m)){l=m.length;for(n=0;n<l;n++){a(o,m[n])}}else{a(o,m)}}}i={tag:"form",action:this.getUrl(),method:this.getMethod(),target:this.target||"_self",style:"display:none",cn:k};if(c.length){i.encoding=i.enctype="multipart/form-data"}q=Ext.DomHelper.append(Ext.getBody(),i);b=c.length;for(p=0;p<b;p++){j=c[p];if(j.rendered){q.appendChild(j.extractFileInput())}}return q},onSuccess:function(b){var c=this.form,d=true,a=this.processResponse(b);if(a!==true&&!a.success){if(a.errors){c.markInvalid(a.errors)}this.failureType=Ext.form.action.Action.SERVER_INVALID;d=false}c.afterAction(this,d)},handleResponse:function(d){var h=this.form,e=h.errorReader,c,j,g,a,b;if(e){c=e.read(d);b=c.records;j=[];if(b){for(g=0,a=b.length;g<a;g++){j[g]=b[g].data}}if(j.length<1){j=null}return{success:c.success,errors:j}}return Ext.decode(d.responseText)}});Ext.define("Ext.util.ComponentDragger",{extend:"Ext.dd.DragTracker",autoStart:500,constructor:function(a,b){this.comp=a;this.initialConstrainTo=b.constrainTo;this.callParent([b])},onStart:function(c){var b=this,a=b.comp;this.startPosition=a.el.getXY();if(a.ghost&&!a.liveDrag){b.proxy=a.ghost();b.dragTarget=b.proxy.header.el}if(b.constrain||b.constrainDelegate){b.constrainTo=b.calculateConstrainRegion()}if(a.beginDrag){a.beginDrag()}},calculateConstrainRegion:function(){var e=this,b=e.comp,i=e.initialConstrainTo,g,h,a=e.proxy?e.proxy.el:b.el,d=(!e.constrainDelegate&&a.shadow&&!a.shadowDisabled)?a.shadow.getShadowSize():0;if(!(i instanceof Ext.util.Region)){i=Ext.fly(i).getViewRegion()}if(d){i.adjust(d[0],-d[1],-d[2],d[3])}if(!e.constrainDelegate){g=Ext.fly(e.dragTarget).getRegion();h=a.getRegion();i.adjust(g.top-h.top,g.right-h.right,g.bottom-h.bottom,g.left-h.left)}return i},onDrag:function(c){var b=this,a=(b.proxy&&!b.comp.liveDrag)?b.proxy:b.comp,d=b.getOffset(b.constrain||b.constrainDelegate?"dragTarget":null);a.setPagePosition(b.startPosition[0]+d[0],b.startPosition[1]+d[1])},onEnd:function(b){var a=this.comp;if(this.proxy&&!a.liveDrag){a.unghost()}if(a.endDrag){a.endDrag()}}});Ext.define("Ext.window.Window",{extend:"Ext.panel.Panel",alternateClassName:"Ext.Window",requires:["Ext.util.ComponentDragger","Ext.util.Region","Ext.EventManager"],alias:"widget.window",baseCls:Ext.baseCSSPrefix+"window",resizable:true,draggable:true,constrain:false,constrainHeader:false,plain:false,minimizable:false,maximizable:false,minHeight:50,minWidth:50,expandOnShow:true,collapsible:false,closable:true,hidden:true,autoRender:true,hideMode:"offsets",floating:true,ariaRole:"alertdialog",itemCls:Ext.baseCSSPrefix+"window-item",initialAlphaNum:/^[a-z0-9]/,overlapHeader:true,ignoreHeaderBorderManagement:true,alwaysFramed:true,isWindow:true,initComponent:function(){var a=this;a.frame=false;a.callParent();a.addEvents("resize","maximize","minimize","restore");if(a.plain){a.addClsWithUI("plain")}if(a.modal){a.ariaRole="dialog"}if(a.floating){a.on({element:"el",mousedown:a.onMouseDown,scope:a})}a.addStateEvents(["maximize","restore","resize","dragend"])},getElConfig:function(){var b=this,a;a=b.callParent();a.tabIndex=-1;return a},getState:function(){var b=this,c=b.callParent()||{},a=!!b.maximized;c.maximized=a;Ext.apply(c,{size:a?b.restoreSize:b.getSize(),pos:a?b.restorePos:b.getPosition()});return c},applyState:function(b){var a=this;if(b){a.maximized=b.maximized;if(a.maximized){a.hasSavedRestore=true;a.restoreSize=b.size;a.restorePos=b.pos}else{Ext.apply(a,{width:b.size.width,height:b.size.height,x:b.pos[0],y:b.pos[1]})}}},onMouseDown:function(b){var a;if(this.floating){if(Ext.fly(b.getTarget()).focusable()){a=true}this.toFront(a)}},onRender:function(b,a){var c=this;c.callParent(arguments);c.focusEl=c.el;if(c.maximizable){c.header.on({scope:c,dblclick:c.toggleMaximize})}},afterRender:function(){var a=this,b;a.callParent();if(a.maximized){a.maximized=false;a.maximize()}if(a.closable){b=a.getKeyMap();b.on(27,a.onEsc,a)}else{b=a.keyMap}if(b&&a.hidden){b.disable()}},initDraggable:function(){var b=this,a;if(!b.header){b.updateHeader(true)}if(b.header){a=Ext.applyIf({el:b.el,delegate:"#"+Ext.escapeId(b.header.id)},b.draggable);if(b.constrain||b.constrainHeader){a.constrain=b.constrain;a.constrainDelegate=b.constrainHeader;a.constrainTo=b.constrainTo||b.container}b.dd=new Ext.util.ComponentDragger(this,a);b.relayEvents(b.dd,["dragstart","drag","dragend"])}},onEsc:function(a,b){if(!Ext.FocusManager||!Ext.FocusManager.enabled||Ext.FocusManager.focusedCmp===this){b.stopEvent();this.close()}},beforeDestroy:function(){var a=this;if(a.rendered){delete this.animateTarget;a.hide();Ext.destroy(a.keyMap)}a.callParent()},addTools:function(){var a=this;a.callParent();if(a.minimizable){a.addTool({type:"minimize",handler:Ext.Function.bind(a.minimize,a,[])})}if(a.maximizable){a.addTool({type:"maximize",handler:Ext.Function.bind(a.maximize,a,[])});a.addTool({type:"restore",handler:Ext.Function.bind(a.restore,a,[]),hidden:true})}},getFocusEl:function(){return this.getDefaultFocus()},getDefaultFocus:function(){var c=this,b,d=c.defaultButton||c.defaultFocus,a;if(d!==undefined){if(Ext.isNumber(d)){b=c.query("button")[d]}else{if(Ext.isString(d)){a=d;if(a.match(c.initialAlphaNum)){b=c.down("#"+a)}if(!b){b=c.down(a)}}else{if(d.focus){b=d}}}}return b||c.el},onFocus:function(){var b=this,a;if((Ext.FocusManager&&Ext.FocusManager.enabled)||((a=b.getDefaultFocus())===b)){b.callParent(arguments)}else{a.focus()}},beforeLayout:function(){var a=this.el.shadow;this.callParent();if(a){a.hide()}},onShow:function(){var a=this;a.callParent(arguments);if(a.expandOnShow){a.expand(false)}a.syncMonitorWindowResize();if(a.keyMap){a.keyMap.enable()}},doClose:function(){var a=this;if(a.hidden){a.fireEvent("close",a);if(a.closeAction=="destroy"){this.destroy()}}else{a.hide(a.animateTarget,a.doClose,a)}},afterHide:function(){var a=this;a.syncMonitorWindowResize();if(a.keyMap){a.keyMap.disable()}a.callParent(arguments)},onWindowResize:function(){var b=this,a;if(b.maximized){b.fitContainer()}else{a=b.getSizeModel();if(a.width.natural||a.height.natural){b.updateLayout()}}b.doConstrain()},minimize:function(){this.fireEvent("minimize",this);return this},afterCollapse:function(){var a=this;if(a.maximizable){a.tools.maximize.hide();a.tools.restore.hide()}if(a.resizer){a.resizer.disable()}a.callParent(arguments)},afterExpand:function(){var a=this;if(a.maximized){a.tools.restore.show()}else{if(a.maximizable){a.tools.maximize.show()}}if(a.resizer){a.resizer.enable()}a.callParent(arguments)},maximize:function(){var a=this;if(!a.maximized){a.expand(false);if(!a.hasSavedRestore){a.restoreSize=a.getSize();a.restorePos=a.getPosition(true)}if(a.maximizable){a.tools.maximize.hide();a.tools.restore.show()}a.maximized=true;a.el.disableShadow();if(a.dd){a.dd.disable()}if(a.resizer){a.resizer.disable()}if(a.collapseTool){a.collapseTool.hide()}a.el.addCls(Ext.baseCSSPrefix+"window-maximized");a.container.addCls(Ext.baseCSSPrefix+"window-maximized-ct");a.syncMonitorWindowResize();a.fitContainer();a.fireEvent("maximize",a)}return a},restore:function(){var a=this,b=a.tools;if(a.maximized){delete a.hasSavedRestore;a.removeCls(Ext.baseCSSPrefix+"window-maximized");if(b.restore){b.restore.hide()}if(b.maximize){b.maximize.show()}if(a.collapseTool){a.collapseTool.show()}a.maximized=false;a.setPosition(a.restorePos);a.setSize(a.restoreSize);delete a.restorePos;delete a.restoreSize;a.el.enableShadow(true);if(a.dd){a.dd.enable()}if(a.resizer){a.resizer.enable()}a.container.removeCls(Ext.baseCSSPrefix+"window-maximized-ct");a.syncMonitorWindowResize();a.doConstrain();a.fireEvent("restore",a)}return a},syncMonitorWindowResize:function(){var b=this,c=b._monitoringResize,d=b.monitorResize||b.constrain||b.constrainHeader||b.maximized,a=b.hidden||b.destroying||b.isDestroyed;if(d&&!a){if(!c){Ext.EventManager.onWindowResize(b.onWindowResize,b);b._monitoringResize=true}}else{if(c){Ext.EventManager.removeResizeListener(b.onWindowResize,b);b._monitoringResize=false}}},toggleMaximize:function(){return this[this.maximized?"restore":"maximize"]()}});Ext.define("Ext.layout.component.field.Field",{extend:"Ext.layout.component.Auto",alias:"layout.field",uses:["Ext.tip.QuickTip","Ext.util.TextMetrics","Ext.util.CSS"],type:"field",naturalSizingProp:"size",beginLayout:function(g){var e=this,a=e.owner,c=g.widthModel,b=a[e.naturalSizingProp],d;e.callParent(arguments);g.labelStrategy=e.getLabelStrategy();g.errorStrategy=e.getErrorStrategy();g.labelContext=g.getEl("labelEl");g.bodyCellContext=g.getEl("bodyEl");g.inputContext=g.getEl("inputEl");g.errorContext=g.getEl("errorEl");if((Ext.isIE6||Ext.isIE7)&&Ext.isStrict&&g.inputContext){e.ieInputWidthAdjustment=g.inputContext.getPaddingInfo().width+g.inputContext.getBorderInfo().width}g.labelStrategy.prepare(g,a);g.errorStrategy.prepare(g,a);if(c.shrinkWrap){e.beginLayoutShrinkWrap(g)}else{if(c.natural){if(typeof b=="number"&&!a.inputWidth){e.beginLayoutFixed(g,(d=b*6.5+20),"px")}else{e.beginLayoutShrinkWrap(g)}g.setWidth(d,false)}else{e.beginLayoutFixed(g,"100","%")}}},beginLayoutFixed:function(c,b,e){var a=c.target,d=a.inputEl,g=a.inputWidth;a.el.setStyle("table-layout","fixed");a.bodyEl.setStyle("width",b+e);if(d&&g){d.setStyle("width",g+"px")}c.isFixed=true},beginLayoutShrinkWrap:function(b){var a=b.target,c=a.inputEl,d=a.inputWidth;if(c&&c.dom){c.dom.removeAttribute("size");if(d){c.setStyle("width",d+"px")}}a.el.setStyle("table-layout","auto");a.bodyEl.setStyle("width","")},finishedLayout:function(b){var a=this.owner;this.callParent(arguments);b.labelStrategy.finishedLayout(b,a);b.errorStrategy.finishedLayout(b,a)},calculateOwnerHeightFromContentHeight:function(b,a){return a},measureContentHeight:function(a){return a.el.getHeight()},measureContentWidth:function(a){return a.el.getWidth()},measureLabelErrorHeight:function(a){return a.labelStrategy.getHeight(a)+a.errorStrategy.getHeight(a)},onFocus:function(){this.getErrorStrategy().onFocus(this.owner)},getLabelStrategy:function(){var b=this,c=b.labelStrategies,a=b.owner.labelAlign;return c[a]||c.base},getErrorStrategy:function(){var c=this,a=c.owner,d=c.errorStrategies,b=a.msgTarget;return !a.preventMark&&Ext.isString(b)?(d[b]||d.elementId):d.none},labelStrategies:(function(){var a={prepare:function(e,b){var c=b.labelCls+"-"+b.labelAlign,d=b.labelEl;if(d){d.addCls(c)}},getHeight:function(){return 0},finishedLayout:Ext.emptyFn};return{base:a,top:Ext.applyIf({getHeight:function(e){var c=e.labelContext,d=c.props,b=d.height;if(b===undefined){d.height=b=c.el.getHeight()}return b}},a),left:a,right:a}}()),errorStrategies:(function(){function d(h){var i=Ext.layout.component.field.Field.tip,j;if(i&&i.isVisible()){j=i.activeTarget;if(j&&j.el===h.getActionEl().dom){i.toFront(true)}}}var c=Ext.applyIf,b=Ext.emptyFn,a=Ext.baseCSSPrefix+"form-invalid-icon",g,e={prepare:function(j,h){var i=h.errorEl;if(i){i.setDisplayed(false)}},getHeight:function(){return 0},onFocus:b,finishedLayout:b};return{none:e,side:c({prepare:function(k,i){var m=i.errorEl,j=i.sideErrorCell,h=i.hasActiveError(),l;if(!g){g=(l=Ext.getBody().createChild({style:"position:absolute",cls:a})).getWidth();l.remove()}m.addCls(a);m.set({"data-errorqtip":i.getActiveError()||""});if(i.autoFitErrors){m.setDisplayed(h)}else{m.setVisible(h)}if(j&&i.autoFitErrors){j.setDisplayed(h)}i.bodyEl.dom.colSpan=i.getBodyColspan();Ext.layout.component.field.Field.initTip()},onFocus:d},e),under:c({prepare:function(j,h){var k=h.errorEl,i=Ext.baseCSSPrefix+"form-invalid-under";k.addCls(i);k.setDisplayed(h.hasActiveError())},getHeight:function(k){var h=0,i,j;if(k.target.hasActiveError()){i=k.errorContext;j=i.props;h=j.height;if(h===undefined){j.height=h=i.el.getHeight()}}return h}},e),qtip:c({prepare:function(i,h){Ext.layout.component.field.Field.initTip();h.getActionEl().set({"data-errorqtip":h.getActiveError()||""})},onFocus:d},e),title:c({prepare:function(i,h){h.el.set({title:h.getActiveError()||""})}},e),elementId:c({prepare:function(i,h){var j=Ext.fly(h.msgTarget);if(j){j.dom.innerHTML=h.getActiveError()||"";j.setDisplayed(h.hasActiveError())}}},e)}}()),statics:{initTip:function(){var a=this.tip;if(!a){a=this.tip=Ext.create("Ext.tip.QuickTip",{baseCls:Ext.baseCSSPrefix+"form-invalid-tip"});a.tagConfig=Ext.apply({},{attribute:"errorqtip"},a.tagConfig)}},destroyTip:function(){var a=this.tip;if(a){a.destroy();delete this.tip}}}});Ext.define("Ext.layout.component.field.Text",{extend:"Ext.layout.component.field.Field",alias:"layout.textfield",requires:["Ext.util.TextMetrics"],type:"textfield",canGrowWidth:true,beginLayoutCycle:function(b){var a=this;a.callParent(arguments);if(b.shrinkWrap){b.inputContext.el.setStyle("height","")}},measureContentWidth:function(c){var h=this,b=h.owner,a=h.callParent(arguments),g=c.inputContext,k,j,d,i,e;if(b.grow&&h.canGrowWidth&&!c.state.growHandled){k=b.inputEl;j=Ext.util.Format.htmlEncode(k.dom.value||(b.hasFocus?"":b.emptyText)||"");j+=b.growAppend;d=k.getTextWidth(j)+g.getFrameInfo().width;i=b.growMax;e=Math.min(i,a);i=Math.max(b.growMin,i,e);d=Ext.Number.constrain(d,b.growMin,i);g.setWidth(d);c.state.growHandled=true;g.domBlock(h,"width");a=NaN}return a},publishInnerHeight:function(b,a){b.inputContext.setHeight(a-this.measureLabelErrorHeight(b))},beginLayoutFixed:function(d,a,e){var b=this,c=b.ieInputWidthAdjustment;if(c){b.owner.bodyEl.setStyle("padding-right",c+"px");if(e==="px"){a-=c}}b.callParent(arguments)}});Ext.define("Ext.form.Labelable",{requires:["Ext.XTemplate"],autoEl:{tag:"table",cellpadding:0},childEls:["labelCell","labelEl","bodyEl","sideErrorCell","errorEl","inputRow","bottomPlaceHolder"],labelableRenderTpl:['<tr id="{id}-inputRow" <tpl if="inFormLayout">id="{id}"</tpl>>','<tpl if="labelOnLeft">','<td id="{id}-labelCell" style="{labelCellStyle}" {labelCellAttrs}>',"{beforeLabelTpl}",'<label id="{id}-labelEl" {labelAttrTpl}<tpl if="inputId"> for="{inputId}"</tpl> class="{labelCls}"','<tpl if="labelStyle"> style="{labelStyle}"</tpl>>',"{beforeLabelTextTpl}",'<tpl if="fieldLabel">{fieldLabel}{labelSeparator}</tpl>',"{afterLabelTextTpl}","</label>","{afterLabelTpl}","</td>","</tpl>",'<td class="{baseBodyCls} {fieldBodyCls}" id="{id}-bodyEl" colspan="{bodyColspan}" role="presentation">',"{beforeBodyEl}","<tpl if=\"labelAlign=='top'\">","{beforeLabelTpl}",'<div id="{id}-labelCell" style="{labelCellStyle}">','<label id="{id}-labelEl" {labelAttrTpl}<tpl if="inputId"> for="{inputId}"</tpl> class="{labelCls}"','<tpl if="labelStyle"> style="{labelStyle}"</tpl>>',"{beforeLabelTextTpl}",'<tpl if="fieldLabel">{fieldLabel}{labelSeparator}</tpl>',"{afterLabelTextTpl}","</label>","</div>","{afterLabelTpl}","</tpl>","{beforeSubTpl}","{[values.$comp.getSubTplMarkup()]}","{afterSubTpl}","<tpl if=\"msgTarget==='side'\">","{afterBodyEl}","</td>","<td id=\"{id}-sideErrorCell\" vAlign=\"{[values.labelAlign==='top' && !values.hideLabel ? 'bottom' : 'middle']}\" style=\"{[values.autoFitErrors ? 'display:none' : '']}\" width=\"{errorIconWidth}\">",'<div id="{id}-errorEl" class="{errorMsgCls}" style="display:none;width:{errorIconWidth}px"></div>',"</td>","<tpl elseif=\"msgTarget=='under'\">",'<div id="{id}-errorEl" class="{errorMsgClass}" colspan="2" style="display:none"></div>',"{afterBodyEl}","</td>","</tpl>","</tr>",{disableFormats:true}],activeErrorsTpl:['<tpl if="errors && errors.length">','<ul><tpl for="errors"><li>{.}</li></tpl></ul>',"</tpl>"],isFieldLabelable:true,formItemCls:Ext.baseCSSPrefix+"form-item",labelCls:Ext.baseCSSPrefix+"form-item-label",errorMsgCls:Ext.baseCSSPrefix+"form-error-msg",baseBodyCls:Ext.baseCSSPrefix+"form-item-body",fieldBodyCls:"",clearCls:Ext.baseCSSPrefix+"clear",invalidCls:Ext.baseCSSPrefix+"form-invalid",fieldLabel:undefined,labelAlign:"left",labelWidth:100,labelPad:5,labelSeparator:":",hideLabel:false,hideEmptyLabel:true,preventMark:false,autoFitErrors:true,msgTarget:"qtip",noWrap:true,labelableInsertions:["beforeBodyEl","afterBodyEl","beforeLabelTpl","afterLabelTpl","beforeSubTpl","afterSubTpl","beforeLabelTextTpl","afterLabelTextTpl","labelAttrTpl"],labelableRenderProps:["allowBlank","id","labelAlign","fieldBodyCls","baseBodyCls","clearCls","labelSeparator","msgTarget"],initLabelable:function(){var a=this,b=a.padding;if(b){a.padding=undefined;a.extraMargins=Ext.Element.parseBox(b)}a.addCls(a.formItemCls);a.lastActiveError="";a.addEvents("errorchange")},trimLabelSeparator:function(){var c=this,d=c.labelSeparator,a=c.fieldLabel||"",b=a.substr(a.length-1);return b===d?a.slice(0,-1):a},getFieldLabel:function(){return this.trimLabelSeparator()},setFieldLabel:function(b){b=b||"";var c=this,d=c.labelSeparator,a=c.labelEl;c.fieldLabel=b;if(c.rendered){if(Ext.isEmpty(b)&&c.hideEmptyLabel){a.parent().setDisplayed("none")}else{if(d){b=c.trimLabelSeparator()+d}a.update(b);a.parent().setDisplayed("")}c.updateLayout()}},getInsertionRenderData:function(d,e){var b=e.length,a,c;while(b--){a=e[b];c=this[a];if(c){if(typeof c!="string"){if(!c.isTemplate){c=Ext.XTemplate.getTpl(this,a)}c=c.apply(d)}}d[a]=c||""}return d},getLabelableRenderData:function(){var b=this,c,d,a=b.labelAlign==="top";if(!Ext.form.Labelable.errorIconWidth){Ext.form.Labelable.errorIconWidth=(d=Ext.resetElement.createChild({style:"position:absolute",cls:Ext.baseCSSPrefix+"form-invalid-icon"})).getWidth();d.remove()}c=Ext.copyTo({inFormLayout:b.ownerLayout&&b.ownerLayout.type==="form",inputId:b.getInputId(),labelOnLeft:!a,hideLabel:!b.hasVisibleLabel(),fieldLabel:b.getFieldLabel(),labelCellStyle:b.getLabelCellStyle(),labelCellAttrs:b.getLabelCellAttrs(),labelCls:b.getLabelCls(),labelStyle:b.getLabelStyle(),bodyColspan:b.getBodyColspan(),externalError:!b.autoFitErrors,errorMsgCls:b.getErrorMsgCls(),errorIconWidth:Ext.form.Labelable.errorIconWidth},b,b.labelableRenderProps,true);b.getInsertionRenderData(c,b.labelableInsertions);return c},beforeLabelableRender:function(){var a=this;if(a.ownerLayout){a.addCls(Ext.baseCSSPrefix+a.ownerLayout.type+"-form-item")}},onLabelableRender:function(){var c=this,d,a,b={};if(c.extraMargins){d=c.el.getMargin();for(a in d){if(d.hasOwnProperty(a)){b["margin-"+a]=(d[a]+c.extraMargins[a])+"px"}}c.el.setStyle(b)}},hasVisibleLabel:function(){if(this.hideLabel){return false}return !(this.hideEmptyLabel&&!this.getFieldLabel())},getBodyColspan:function(){var b=this,a;if(b.msgTarget==="side"&&(!b.autoFitErrors||b.hasActiveError())){a=1}else{a=2}if(b.labelAlign!=="top"&&!b.hasVisibleLabel()){a++}return a},getLabelCls:function(){var b=this.labelCls,a=this.labelClsExtra;if(this.labelAlign==="top"){b+="-top"}return a?b+" "+a:b},getLabelCellStyle:function(){var b=this,a=b.hideLabel||(!b.fieldLabel&&b.hideEmptyLabel);return a?"display:none;":""},getErrorMsgCls:function(){var b=this,a=(b.hideLabel||(!b.fieldLabel&&b.hideEmptyLabel));return b.errorMsgCls+(!a&&b.labelAlign==="top"?" "+Ext.baseCSSPrefix+"lbl-top-err-icon":"")},getLabelCellAttrs:function(){var c=this,b=c.labelAlign,a="";if(b!=="top"){a='valign="top" halign="'+b+'" width="'+(c.labelWidth+c.labelPad)+'"'}return a+' class="'+Ext.baseCSSPrefix+'field-label-cell"'},getLabelStyle:function(){var c=this,b=c.labelPad,a="";if(c.labelAlign!=="top"){if(c.labelWidth){a="width:"+c.labelWidth+"px;"}a+="margin-right:"+b+"px;"}return a+(c.labelStyle||"")},getSubTplMarkup:function(){return""},getInputId:function(){return""},getActiveError:function(){return this.activeError||""},hasActiveError:function(){return !!this.getActiveError()},setActiveError:function(a){this.setActiveErrors(a)},getActiveErrors:function(){return this.activeErrors||[]},setActiveErrors:function(a){a=Ext.Array.from(a);this.activeError=a[0];this.activeErrors=a;this.activeError=this.getTpl("activeErrorsTpl").apply({errors:a});this.renderActiveError()},unsetActiveError:function(){delete this.activeError;delete this.activeErrors;this.renderActiveError()},renderActiveError:function(){var c=this,b=c.getActiveError(),a=!!b;if(b!==c.lastActiveError){c.fireEvent("errorchange",c,b);c.lastActiveError=b}if(c.rendered&&!c.isDestroyed&&!c.preventMark){c.el[a?"addCls":"removeCls"](c.invalidCls);c.getActionEl().dom.setAttribute("aria-invalid",a);if(c.errorEl){c.errorEl.dom.innerHTML=b}}},setFieldDefaults:function(c){var b=this,d,a;for(a in c){if(c.hasOwnProperty(a)){d=c[a];if(!b.hasOwnProperty(a)){b[a]=d}}}}});Ext.define("Ext.form.field.Field",{isFormField:true,disabled:false,submitValue:true,validateOnChange:true,suspendCheckChange:0,initField:function(){this.addEvents("change","validitychange","dirtychange");this.initValue()},initValue:function(){var a=this;a.value=a.transformOriginalValue(a.value);a.originalValue=a.lastValue=a.value;a.suspendCheckChange++;a.setValue(a.value);a.suspendCheckChange--},transformOriginalValue:function(a){return a},getName:function(){return this.name},getValue:function(){return this.value},setValue:function(b){var a=this;a.value=b;a.checkChange();return a},isEqual:function(b,a){return String(b)===String(a)},isEqualAsString:function(b,a){return String(Ext.value(b,""))===String(Ext.value(a,""))},getSubmitData:function(){var a=this,b=null;if(!a.disabled&&a.submitValue&&!a.isFileUpload()){b={};b[a.getName()]=""+a.getValue()}return b},getModelData:function(){var a=this,b=null;if(!a.disabled&&!a.isFileUpload()){b={};b[a.getName()]=a.getValue()}return b},reset:function(){var a=this;a.beforeReset();a.setValue(a.originalValue);a.clearInvalid();delete a.wasValid},beforeReset:Ext.emptyFn,resetOriginalValue:function(){this.originalValue=this.getValue();this.checkDirty()},checkChange:function(){if(!this.suspendCheckChange){var c=this,b=c.getValue(),a=c.lastValue;if(!c.isEqual(b,a)&&!c.isDestroyed){c.lastValue=b;c.fireEvent("change",c,b,a);c.onChange(b,a)}}},onChange:function(b,a){if(this.validateOnChange){this.validate()}this.checkDirty()},isDirty:function(){var a=this;return !a.disabled&&!a.isEqual(a.getValue(),a.originalValue)},checkDirty:function(){var a=this,b=a.isDirty();if(b!==a.wasDirty){a.fireEvent("dirtychange",a,b);a.onDirtyChange(b);a.wasDirty=b}},onDirtyChange:Ext.emptyFn,getErrors:function(a){return[]},isValid:function(){var a=this;return a.disabled||Ext.isEmpty(a.getErrors())},validate:function(){var a=this,b=a.isValid();if(b!==a.wasValid){a.wasValid=b;a.fireEvent("validitychange",a,b)}return b},batchChanges:function(a){try{this.suspendCheckChange++;a()}catch(b){throw b}finally{this.suspendCheckChange--}this.checkChange()},isFileUpload:function(){return false},extractFileInput:function(){return null},markInvalid:Ext.emptyFn,clearInvalid:Ext.emptyFn});Ext.define("Ext.form.field.Base",{extend:"Ext.Component",mixins:{labelable:"Ext.form.Labelable",field:"Ext.form.field.Field"},alias:"widget.field",alternateClassName:["Ext.form.Field","Ext.form.BaseField"],requires:["Ext.util.DelayedTask","Ext.XTemplate","Ext.layout.component.field.Field"],fieldSubTpl:['<input id="{id}" type="{type}" {inputAttrTpl}',' size="1"','<tpl if="name"> name="{name}"</tpl>','<tpl if="value"> value="{[Ext.util.Format.htmlEncode(values.value)]}"</tpl>','<tpl if="placeholder"> placeholder="{placeholder}"</tpl>','{%if (values.maxLength !== undefined){%} maxlength="{maxLength}"{%}%}','<tpl if="readOnly"> readonly="readonly"</tpl>','<tpl if="disabled"> disabled="disabled"</tpl>','<tpl if="tabIdx"> tabIndex="{tabIdx}"</tpl>','<tpl if="fieldStyle"> style="{fieldStyle}"</tpl>',' class="{fieldCls} {typeCls} {editableCls}" autocomplete="off"/>',{disableFormats:true}],subTplInsertions:["inputAttrTpl"],inputType:"text",invalidText:"The value in this field is invalid",fieldCls:Ext.baseCSSPrefix+"form-field",focusCls:"form-focus",dirtyCls:Ext.baseCSSPrefix+"form-dirty",checkChangeEvents:Ext.isIE&&(!document.documentMode||document.documentMode<9)?["change","propertychange"]:["change","input","textInput","keyup","dragdrop"],checkChangeBuffer:50,componentLayout:"field",readOnly:false,readOnlyCls:Ext.baseCSSPrefix+"form-readonly",validateOnBlur:true,hasFocus:false,baseCls:Ext.baseCSSPrefix+"field",maskOnDisable:false,initComponent:function(){var a=this;a.callParent();a.subTplData=a.subTplData||{};a.addEvents("specialkey","writeablechange");a.initLabelable();a.initField();if(!a.name){a.name=a.getInputId()}},beforeRender:function(){var a=this;a.callParent(arguments);a.beforeLabelableRender(arguments);if(a.readOnly){a.addCls(a.readOnlyCls)}},getInputId:function(){return this.inputId||(this.inputId=this.id+"-inputEl")},getSubTplData:function(){var c=this,b=c.inputType,a=c.getInputId(),d;d=Ext.apply({id:a,cmpId:c.id,name:c.name||a,disabled:c.disabled,readOnly:c.readOnly,value:c.getRawValue(),type:b,fieldCls:c.fieldCls,fieldStyle:c.getFieldStyle(),tabIdx:c.tabIndex,typeCls:Ext.baseCSSPrefix+"form-"+(b==="password"?"text":b)},c.subTplData);c.getInsertionRenderData(d,c.subTplInsertions);return d},afterFirstLayout:function(){this.callParent();var a=this.inputEl;if(a){a.selectable()}},applyRenderSelectors:function(){var a=this;a.callParent();a.inputEl=a.el.getById(a.getInputId())},getSubTplMarkup:function(){return this.getTpl("fieldSubTpl").apply(this.getSubTplData())},initRenderTpl:function(){var a=this;if(!a.hasOwnProperty("renderTpl")){a.renderTpl=a.getTpl("labelableRenderTpl")}return a.callParent()},initRenderData:function(){return Ext.applyIf(this.callParent(),this.getLabelableRenderData())},setFieldStyle:function(a){var b=this,c=b.inputEl;if(c){c.applyStyles(a)}b.fieldStyle=a},getFieldStyle:function(){return"width:100%;"+(Ext.isObject(this.fieldStyle)?Ext.DomHelper.generateStyles(this.fieldStyle):this.fieldStyle||"")},onRender:function(){var a=this;a.callParent(arguments);a.onLabelableRender();a.renderActiveError()},getFocusEl:function(){return this.inputEl},isFileUpload:function(){return this.inputType==="file"},extractFileInput:function(){var b=this,a=b.isFileUpload()?b.inputEl.dom:null,c;if(a){c=a.cloneNode(true);a.parentNode.replaceChild(c,a);b.inputEl=Ext.get(c)}return a},getSubmitData:function(){var a=this,b=null,c;if(!a.disabled&&a.submitValue&&!a.isFileUpload()){c=a.getSubmitValue();if(c!==null){b={};b[a.getName()]=c}}return b},getSubmitValue:function(){return this.processRawValue(this.getRawValue())},getRawValue:function(){var b=this,a=(b.inputEl?b.inputEl.getValue():Ext.value(b.rawValue,""));b.rawValue=a;return a},setRawValue:function(b){var a=this;b=Ext.value(a.transformRawValue(b),"");a.rawValue=b;if(a.inputEl){a.inputEl.dom.value=b}return b},transformRawValue:function(a){return a},valueToRaw:function(a){return""+Ext.value(a,"")},rawToValue:function(a){return a},processRawValue:function(a){return a},getValue:function(){var a=this,b=a.rawToValue(a.processRawValue(a.getRawValue()));a.value=b;return b},setValue:function(b){var a=this;a.setRawValue(a.valueToRaw(b));return a.mixins.field.setValue.call(a,b)},onBoxReady:function(){var a=this;a.callParent();if(a.setReadOnlyOnBoxReady){a.setReadOnly(a.readOnly)}},onDisable:function(){var a=this,b=a.inputEl;a.callParent();if(b){b.dom.disabled=true;if(a.hasActiveError()){a.clearInvalid();a.needsValidateOnEnable=true}}},onEnable:function(){var a=this,b=a.inputEl;a.callParent();if(b){b.dom.disabled=false;if(a.needsValidateOnEnable){delete a.needsValidateOnEnable;a.forceValidation=true;a.isValid();delete a.forceValidation}}},setReadOnly:function(c){var a=this,b=a.inputEl;c=!!c;a[c?"addCls":"removeCls"](a.readOnlyCls);a.readOnly=c;if(b){b.dom.readOnly=c}else{if(a.rendering){a.setReadOnlyOnBoxReady=true}}a.fireEvent("writeablechange",a,c)},fireKey:function(a){if(a.isSpecialKey()){this.fireEvent("specialkey",this,new Ext.EventObjectImpl(a))}},initEvents:function(){var g=this,i=g.inputEl,b,j,c=g.checkChangeEvents,h,a=c.length,d;if(g.inEditor){g.onBlur=Ext.Function.createBuffered(g.onBlur,10)}if(i){g.mon(i,Ext.EventManager.getKeyEvent(),g.fireKey,g);b=new Ext.util.DelayedTask(g.checkChange,g);g.onChangeEvent=j=function(){b.delay(g.checkChangeBuffer)};for(h=0;h<a;h++){d=c[h];if(d==="propertychange"){g.usesPropertychange=true}g.mon(i,d,j)}}g.callParent()},doComponentLayout:function(){var c=this,d=c.inputEl,a=c.usesPropertychange,b="propertychange",e=c.onChangeEvent;if(a){c.mun(d,b,e)}c.callParent(arguments);if(a){c.mon(d,b,e)}},onDirtyChange:function(a){this[a?"addCls":"removeCls"](this.dirtyCls)},isValid:function(){var b=this,a=b.disabled,c=b.forceValidation||!a;return c?b.validateValue(b.processRawValue(b.getRawValue())):a},validateValue:function(b){var a=this,d=a.getErrors(b),c=Ext.isEmpty(d);if(!a.preventMark){if(c){a.clearInvalid()}else{a.markInvalid(d)}}return c},markInvalid:function(c){var b=this,a=b.getActiveError();b.setActiveErrors(Ext.Array.from(c));if(a!==b.getActiveError()){b.updateLayout()}},clearInvalid:function(){var b=this,a=b.hasActiveError();b.unsetActiveError();if(a){b.updateLayout()}},renderActiveError:function(){var b=this,a=b.hasActiveError();if(b.inputEl){b.inputEl[a?"addCls":"removeCls"](b.invalidCls+"-field")}b.mixins.labelable.renderActiveError.call(b)},getActionEl:function(){return this.inputEl||this.el}});Ext.define("Ext.form.field.VTypes",(function(){var c=/^[a-zA-Z_]+$/,d=/^[a-zA-Z0-9_]+$/,b=/^(\w+)([\-+.][\w]+)*@(\w[\-\w]*\.){1,5}([A-Za-z]){2,6}$/,a=/(((^https?)|(^ftp)):\/\/([\-\w]+\.)+\w{2,3}(\/[%\-\w]+(\.\w{2,})?)*(([\w\-\.\?\\\/+@&#;`~=%!]*)(\.\w{2,})?)*\/?)/i;return{singleton:true,alternateClassName:"Ext.form.VTypes",email:function(e){return b.test(e)},emailText:'This field should be an e-mail address in the format "user@example.com"',emailMask:/[a-z0-9_\.\-@\+]/i,url:function(e){return a.test(e)},urlText:'This field should be a URL in the format "http://www.example.com"',alpha:function(e){return c.test(e)},alphaText:"This field should only contain letters and _",alphaMask:/[a-z_]/i,alphanum:function(e){return d.test(e)},alphanumText:"This field should only contain letters, numbers and _",alphanumMask:/[a-z0-9_]/i}}()));Ext.define("Ext.form.field.Text",{extend:"Ext.form.field.Base",alias:"widget.textfield",requires:["Ext.form.field.VTypes","Ext.layout.component.field.Text"],alternateClassName:["Ext.form.TextField","Ext.form.Text"],size:20,growMin:30,growMax:800,growAppend:"W",allowBlank:true,minLength:0,maxLength:Number.MAX_VALUE,minLengthText:"The minimum length for this field is {0}",maxLengthText:"The maximum length for this field is {0}",blankText:"This field is required",regexText:"",emptyCls:Ext.baseCSSPrefix+"form-empty-field",requiredCls:Ext.baseCSSPrefix+"form-required-field",componentLayout:"textfield",valueContainsPlaceholder:false,initComponent:function(){var a=this;a.callParent();a.addEvents("autosize","keydown","keyup","keypress");a.addStateEvents("change");a.setGrowSizePolicy()},setGrowSizePolicy:function(){if(this.grow){this.shrinkWrap|=1}},initEvents:function(){var b=this,a=b.inputEl;b.callParent();if(b.selectOnFocus||b.emptyText){b.mon(a,"mousedown",b.onMouseDown,b)}if(b.maskRe||(b.vtype&&b.disableKeyFilter!==true&&(b.maskRe=Ext.form.field.VTypes[b.vtype+"Mask"]))){b.mon(a,"keypress",b.filterKeys,b)}if(b.enableKeyEvents){b.mon(a,{scope:b,keyup:b.onKeyUp,keydown:b.onKeyDown,keypress:b.onKeyPress})}},isEqual:function(b,a){return this.isEqualAsString(b,a)},onChange:function(){this.callParent();this.autoSize()},getSubTplData:function(){var b=this,c=b.getRawValue(),e=b.emptyText&&c.length<1,a=b.maxLength,d;if(b.enforceMaxLength){if(a===Number.MAX_VALUE){a=undefined}}else{a=undefined}if(e){if(Ext.supports.Placeholder){d=b.emptyText}else{c=b.emptyText;b.valueContainsPlaceholder=true}}return Ext.apply(b.callParent(),{maxLength:a,readOnly:b.readOnly,placeholder:d,value:c,fieldCls:b.fieldCls+((e&&(d||c))?" "+b.emptyCls:"")+(b.allowBlank?"":" "+b.requiredCls)})},afterRender:function(){this.autoSize();this.callParent()},onMouseDown:function(b){var a=this;if(!a.hasFocus){a.mon(a.inputEl,"mouseup",Ext.emptyFn,a,{single:true,preventDefault:true})}},processRawValue:function(b){var a=this,d=a.stripCharsRe,c;if(d){c=b.replace(d,"");if(c!==b){a.setRawValue(c);b=c}}return b},onDisable:function(){this.callParent();if(Ext.isIE){this.inputEl.dom.unselectable="on"}},onEnable:function(){this.callParent();if(Ext.isIE){this.inputEl.dom.unselectable=""}},onKeyDown:function(a){this.fireEvent("keydown",this,a)},onKeyUp:function(a){this.fireEvent("keyup",this,a)},onKeyPress:function(a){this.fireEvent("keypress",this,a)},reset:function(){this.callParent();this.applyEmptyText()},applyEmptyText:function(){var b=this,a=b.emptyText,c;if(b.rendered&&a){c=b.getRawValue().length<1&&!b.hasFocus;if(Ext.supports.Placeholder){b.inputEl.dom.placeholder=a}else{if(c){b.setRawValue(a);b.valueContainsPlaceholder=true}}if(c){b.inputEl.addCls(b.emptyCls)}b.autoSize()}},afterFirstLayout:function(){this.callParent();if(Ext.isIE&&this.disabled){var a=this.inputEl;if(a){a.dom.unselectable="on"}}},preFocus:function(){var b=this,c=b.inputEl,a=b.emptyText,d;b.callParent(arguments);if((a&&!Ext.supports.Placeholder)&&(c.dom.value===b.emptyText&&b.valueContainsPlaceholder)){b.setRawValue("");d=true;c.removeCls(b.emptyCls);b.valueContainsPlaceholder=false}else{if(Ext.supports.Placeholder){b.inputEl.removeCls(b.emptyCls)}}if(b.selectOnFocus||d){c.dom.select()}},onFocus:function(){var a=this;a.callParent(arguments);if(a.emptyText){a.autoSize()}},postBlur:function(){this.callParent(arguments);this.applyEmptyText()},filterKeys:function(c){if(c.ctrlKey&&!c.altKey){return}var b=c.getKey(),a=String.fromCharCode(c.getCharCode());if((Ext.isGecko||Ext.isOpera)&&(c.isNavKeyPress()||b===c.BACKSPACE||(b===c.DELETE&&c.button===-1))){return}if((!Ext.isGecko&&!Ext.isOpera)&&c.isSpecialKey()&&!a){return}if(!this.maskRe.test(a)){c.stopEvent()}},getState:function(){return this.addPropertyToState(this.callParent(),"value")},applyState:function(a){this.callParent(arguments);if(a.hasOwnProperty("value")){this.setValue(a.value)}},getRawValue:function(){var b=this,a=b.callParent();if(a===b.emptyText&&b.valueContainsPlaceholder){a=""}return a},setValue:function(b){var a=this,c=a.inputEl;if(c&&a.emptyText&&!Ext.isEmpty(b)){c.removeCls(a.emptyCls);a.valueContainsPlaceholder=false}a.callParent(arguments);a.applyEmptyText();return a},getErrors:function(l){var g=this,k=g.callParent(arguments),a=g.validator,d=g.emptyText,c=g.allowBlank,e=g.vtype,h=Ext.form.field.VTypes,i=g.regex,j=Ext.String.format,b;l=l||g.processRawValue(g.getRawValue());if(Ext.isFunction(a)){b=a.call(g,l);if(b!==true){k.push(b)}}if(l.length<1||(l===g.emptyText&&g.valueContainsPlaceholder)){if(!c){k.push(g.blankText)}return k}if(l.length<g.minLength){k.push(j(g.minLengthText,g.minLength))}if(l.length>g.maxLength){k.push(j(g.maxLengthText,g.maxLength))}if(e){if(!h[e](l,g)){k.push(g.vtypeText||h[e+"Text"])}}if(i&&!i.test(l)){k.push(g.regexText||g.invalidText)}return k},selectText:function(i,a){var h=this,c=h.getRawValue(),d=true,g=h.inputEl.dom,e,b;if(c.length>0){i=i===e?0:i;a=a===e?c.length:a;if(g.setSelectionRange){g.setSelectionRange(i,a)}else{if(g.createTextRange){b=g.createTextRange();b.moveStart("character",i);b.moveEnd("character",a-c.length);b.select()}}d=Ext.isGecko||Ext.isOpera}if(d){h.focus()}},autoSize:function(){var a=this;if(a.grow&&a.rendered){a.autoSizing=true;a.updateLayout()}},afterComponentLayout:function(){var b=this,a;b.callParent(arguments);if(b.autoSizing){a=b.inputEl.getWidth();if(a!==b.lastInputWidth){b.fireEvent("autosize",b,a);b.lastInputWidth=a;delete b.autoSizing}}}});Ext.define("Ext.layout.component.field.TextArea",{extend:"Ext.layout.component.field.Text",alias:"layout.textareafield",type:"textareafield",canGrowWidth:false,naturalSizingProp:"cols",beginLayout:function(a){this.callParent(arguments);a.target.inputEl.setStyle("height","")},measureContentHeight:function(b){var e=this,a=e.owner,k=e.callParent(arguments),c,i,h,g,d,j;if(a.grow&&!b.state.growHandled){c=b.inputContext;i=a.inputEl;d=i.getWidth(true);h=Ext.util.Format.htmlEncode(i.dom.value)||"&#160;";h+=a.growAppend;h=h.replace(/\n/g,"<br/>");j=Ext.util.TextMetrics.measure(i,h,d).height+c.getBorderInfo().height+c.getPaddingInfo().height;j=Ext.Number.constrain(j,a.growMin,a.growMax);c.setHeight(j);b.state.growHandled=true;c.domBlock(e,"height");k=NaN}return k}});Ext.define("Ext.form.field.TextArea",{extend:"Ext.form.field.Text",alias:["widget.textareafield","widget.textarea"],alternateClassName:"Ext.form.TextArea",requires:["Ext.XTemplate","Ext.layout.component.field.TextArea","Ext.util.DelayedTask"],fieldSubTpl:['<textarea id="{id}" {inputAttrTpl}','<tpl if="name"> name="{name}"</tpl>','<tpl if="rows"> rows="{rows}" </tpl>','<tpl if="cols"> cols="{cols}" </tpl>','<tpl if="placeholder"> placeholder="{placeholder}"</tpl>','<tpl if="size"> size="{size}"</tpl>','<tpl if="maxLength !== undefined"> maxlength="{maxLength}"</tpl>','<tpl if="readOnly"> readonly="readonly"</tpl>','<tpl if="disabled"> disabled="disabled"</tpl>','<tpl if="tabIdx"> tabIndex="{tabIdx}"</tpl>',' class="{fieldCls} {typeCls}" ','<tpl if="fieldStyle"> style="{fieldStyle}"</tpl>',' autocomplete="off">\n','<tpl if="value">{[Ext.util.Format.htmlEncode(values.value)]}</tpl>',"</textarea>",{disableFormats:true}],growMin:60,growMax:1000,growAppend:"\n-",cols:20,rows:4,enterIsSpecial:false,preventScrollbars:false,componentLayout:"textareafield",setGrowSizePolicy:Ext.emptyFn,returnRe:/\r/g,getSubTplData:function(){var c=this,b=c.getFieldStyle(),a=c.callParent();if(c.grow){if(c.preventScrollbars){a.fieldStyle=(b||"")+";overflow:hidden;height:"+c.growMin+"px"}}Ext.applyIf(a,{cols:c.cols,rows:c.rows});return a},afterRender:function(){var a=this;a.callParent(arguments);a.needsMaxCheck=a.enforceMaxLength&&a.maxLength!==Number.MAX_VALUE&&!Ext.supports.TextAreaMaxLength;if(a.needsMaxCheck){a.inputEl.on("paste",a.onPaste,a)}},transformRawValue:function(a){return this.stripReturns(a)},transformOriginalValue:function(a){return this.stripReturns(a)},valueToRaw:function(a){a=this.stripReturns(a);return this.callParent([a])},stripReturns:function(a){if(a){a=a.replace(this.returnRe,"")}return a},onPaste:function(b){var a=this;if(!a.pasteTask){a.pasteTask=new Ext.util.DelayedTask(a.pasteCheck,a)}a.pasteTask.delay(1)},pasteCheck:function(){var b=this,c=b.getValue(),a=b.maxLength;if(c.length>a){c=c.substr(0,a);b.setValue(c)}},fireKey:function(d){var b=this,a=d.getKey(),c;if(d.isSpecialKey()&&(b.enterIsSpecial||(a!==d.ENTER||d.hasModifier()))){b.fireEvent("specialkey",b,d)}if(b.needsMaxCheck&&a!==d.BACKSPACE&&a!==d.DELETE&&!d.isNavKeyPress()&&!b.isCutCopyPasteSelectAll(d,a)){c=b.getValue();if(c.length>=b.maxLength){d.stopEvent()}}},isCutCopyPasteSelectAll:function(b,a){if(b.CTRL){return a===b.A||a===b.C||a===b.V||a===b.X}return false},autoSize:function(){var b=this,a;if(b.grow&&b.rendered){b.updateLayout();a=b.inputEl.getHeight();if(a!==b.lastInputHeight){b.fireEvent("autosize",b,a);b.lastInputHeight=a}}},initAria:function(){this.callParent(arguments);this.getActionEl().dom.setAttribute("aria-multiline",true)},beforeDestroy:function(){var a=this.pasteTask;if(a){a.delay()}this.callParent()}});Ext.define("Ext.form.field.Display",{extend:"Ext.form.field.Base",alias:"widget.displayfield",requires:["Ext.util.Format","Ext.XTemplate"],alternateClassName:["Ext.form.DisplayField","Ext.form.Display"],fieldSubTpl:['<div id="{id}"','<tpl if="fieldStyle"> style="{fieldStyle}"</tpl>',' class="{fieldCls}">{value}</div>',{compiled:true,disableFormats:true}],fieldCls:Ext.baseCSSPrefix+"form-display-field",htmlEncode:false,validateOnChange:false,initEvents:Ext.emptyFn,submitValue:false,isDirty:function(){return false},isValid:function(){return true},validate:function(){return true},getRawValue:function(){return this.rawValue},setRawValue:function(b){var a=this,c;b=Ext.value(b,"");a.rawValue=b;if(a.rendered){a.inputEl.dom.innerHTML=a.getDisplayValue();a.updateLayout()}return b},getDisplayValue:function(){var a=this,b=this.getRawValue(),c;if(a.renderer){c=a.renderer.call(a.scope||a,b,a)}else{c=a.htmlEncode?Ext.util.Format.htmlEncode(b):b}return c},getSubTplData:function(){var a=this.callParent(arguments);a.value=this.getDisplayValue();return a}});Ext.define("Ext.layout.container.Anchor",{alias:"layout.anchor",extend:"Ext.layout.container.Container",alternateClassName:"Ext.layout.AnchorLayout",type:"anchor",manageOverflow:2,renderTpl:["{%this.renderBody(out,values);this.renderPadder(out,values)%}"],defaultAnchor:"100%",parseAnchorRE:/^(r|right|b|bottom)$/i,beginLayout:function(c){var j=this,a=0,g,k,e,d,b,h;j.callParent(arguments);e=c.childItems;b=e.length;for(d=0;d<b;++d){k=e[d];g=k.target.anchorSpec;if(g){if(k.widthModel.calculated&&g.right){a|=1}if(k.heightModel.calculated&&g.bottom){a|=2}if(a==3){break}}}c.anchorDimensions=a;if(!Ext.supports.RightMargin&&!j.rightMarginCleanerFn){h=c.targetContext.el;j.rightMarginCleanerFn=Ext.Element.getRightMarginFixCleaner(h);h.addCls(Ext.baseCSSPrefix+"inline-children")}},calculate:function(b){var a=this,c=a.getContainerSize(b);if(b.anchorDimensions!==b.state.calculatedAnchors){a.calculateAnchors(b,c)}if(b.hasDomProp("containerChildrenDone")){if(!c.gotAll){a.done=false}a.calculateContentSize(b,b.anchorDimensions);if(a.done){a.calculateOverflow(b,c,b.anchorDimensions);return}}a.done=false},calculateAnchors:function(h,a){var p=this,l=h.childItems,g=l.length,o=a.gotHeight,j=a.gotWidth,e=a.height,c=a.width,b=h.state,q=(j?1:0)|(o?2:0),m,s,n,r,k,d;b.calculatedAnchors=(b.calculatedAnchors||0)|q;for(k=0;k<g;k++){s=l[k];n=s.getMarginInfo();m=s.target.anchorSpec;if(j&&s.widthModel.calculated){d=m.right(c)-n.width;d=p.adjustWidthAnchor(d,s);s.setWidth(d)}if(o&&s.heightModel.calculated){r=m.bottom(e)-n.height;r=p.adjustHeightAnchor(r,s);s.setHeight(r)}}},finishedLayout:function(b){var a=this.rightMarginCleanerFn;if(a){delete this.rightMarginCleanerFn;b.targetContext.el.removeCls(Ext.baseCSSPrefix+"inline-children");a()}},anchorFactory:{offset:function(a){return function(b){return b+a}},ratio:function(a){return function(b){return Math.floor(b*a)}},standard:function(a){return function(b){return b-a}}},parseAnchor:function(c,g,b){if(c&&c!="none"){var d=this.anchorFactory,e;if(this.parseAnchorRE.test(c)){return d.standard(b-g)}if(c.indexOf("%")!=-1){return d.ratio(parseFloat(c.replace("%",""))*0.01)}e=parseInt(c,10);if(!isNaN(e)){return d.offset(e)}}return null},adjustWidthAnchor:function(b,a){return b},adjustHeightAnchor:function(b,a){return b},configureItem:function(g){var e=this,a=e.owner,d=g.anchor,b,c,h;e.callParent(arguments);if(!g.anchor&&g.items&&!Ext.isNumber(g.width)&&!(Ext.isIE6&&Ext.isStrict)){g.anchor=d=e.defaultAnchor}if(a.anchorSize){if(typeof a.anchorSize=="number"){c=a.anchorSize}else{c=a.anchorSize.width;h=a.anchorSize.height}}else{c=a.initialConfig.width;h=a.initialConfig.height}if(d){b=d.split(" ");g.anchorSpec={right:e.parseAnchor(b[0],g.initialConfig.width,c),bottom:e.parseAnchor(b[1],g.initialConfig.height,h)}}},sizePolicy:{"":{setsWidth:0,setsHeight:0},b:{setsWidth:0,setsHeight:1},r:{"":{setsWidth:1,setsHeight:0},b:{setsWidth:1,setsHeight:1}}},getItemSizePolicy:function(c){var e=c.anchorSpec,a="",d=this.sizePolicy,b;if(e){b=this.owner.getSizeModel();if(e.right&&!b.width.shrinkWrap){d=d.r}if(e.bottom&&!b.height.shrinkWrap){a="b"}}return d[a]}});Ext.define("Ext.window.MessageBox",{extend:"Ext.window.Window",requires:["Ext.toolbar.Toolbar","Ext.form.field.Text","Ext.form.field.TextArea","Ext.form.field.Display","Ext.button.Button","Ext.layout.container.Anchor","Ext.layout.container.HBox","Ext.ProgressBar"],alias:"widget.messagebox",OK:1,YES:2,NO:4,CANCEL:8,OKCANCEL:9,YESNO:6,YESNOCANCEL:14,INFO:Ext.baseCSSPrefix+"message-box-info",WARNING:Ext.baseCSSPrefix+"message-box-warning",QUESTION:Ext.baseCSSPrefix+"message-box-question",ERROR:Ext.baseCSSPrefix+"message-box-error",hideMode:"offsets",closeAction:"hide",resizable:false,title:"&#160;",width:600,height:500,minWidth:250,maxWidth:600,minHeight:110,maxHeight:500,constrain:true,cls:Ext.baseCSSPrefix+"message-box",layout:{type:"vbox",align:"stretch"},defaultTextHeight:75,minProgressWidth:250,minPromptWidth:250,buttonText:{ok:"OK",yes:"Yes",no:"No",cancel:"Cancel"},buttonIds:["ok","yes","no","cancel"],titleText:{confirm:"Confirm",prompt:"Prompt",wait:"Loading...",alert:"Attention"},iconHeight:35,makeButton:function(a){var b=this.buttonIds[a];return new Ext.button.Button({handler:this.btnCallback,itemId:b,scope:this,text:this.buttonText[b],minWidth:75})},btnCallback:function(a){var b=this,c,d;if(b.cfg.prompt||b.cfg.multiline){if(b.cfg.multiline){d=b.textArea}else{d=b.textField}c=d.getValue();d.reset()}a.blur();b.hide();b.userCallback(a.itemId,c,b.cfg)},hide:function(){var a=this;a.dd.endDrag();a.progressBar.reset();a.removeCls(a.cfg.cls);a.callParent(arguments)},initComponent:function(){var e=this,a=e.id,c,b,d;e.title="&#160;";e.topContainer=new Ext.container.Container({layout:"hbox",style:{padding:"10px",overflow:"hidden"},items:[e.iconComponent=new Ext.Component({cls:e.baseCls+"-icon",width:50,height:e.iconHeight}),e.promptContainer=new Ext.container.Container({flex:1,layout:{type:"anchor"},items:[e.msg=new Ext.form.field.Display({id:a+"-displayfield",cls:e.baseCls+"-text"}),e.textField=new Ext.form.field.Text({id:a+"-testfield",anchor:"100%",enableKeyEvents:true,listeners:{keydown:e.onPromptKey,scope:e}}),e.textArea=new Ext.form.field.TextArea({id:a+"-textarea",anchor:"100%",height:75})]})]});e.progressBar=new Ext.ProgressBar({id:a+"-progressbar",margins:"0 10 0 10"});e.items=[e.topContainer,e.progressBar];e.msgButtons=[];for(c=0;c<4;c++){b=e.makeButton(c);e.msgButtons[b.itemId]=b;e.msgButtons.push(b)}e.bottomTb=new Ext.toolbar.Toolbar({id:a+"-toolbar",ui:"footer",dock:"bottom",layout:{pack:"center"},items:[e.msgButtons[0],e.msgButtons[1],e.msgButtons[2],e.msgButtons[3]]});e.dockedItems=[e.bottomTb];d=e.bottomTb.getLayout();d.finishedLayout=Ext.Function.createInterceptor(d.finishedLayout,function(g){e.tbWidth=g.getProp("contentWidth")});e.on("close",e.onClose,e);e.callParent()},onClose:function(){var a=this.header.child("[type=close]");a.itemId="cancel";this.btnCallback(a);delete a.itemId},onPromptKey:function(a,c){var b=this,d;if(c.keyCode===Ext.EventObject.RETURN||c.keyCode===10){if(b.msgButtons.ok.isVisible()){d=true;b.msgButtons.ok.handler.call(b,b.msgButtons.ok)}else{if(b.msgButtons.yes.isVisible()){b.msgButtons.yes.handler.call(b,b.msgButtons.yes);d=true}}if(d){b.textField.blur()}}},reconfigure:function(a){var d=this,c=0,h=true,g=d.maxWidth,e=d.buttonText,b;d.updateButtonText();a=a||{};d.cfg=a;if(a.width){g=a.width}delete d.defaultFocus;d.animateTarget=a.animateTarget||undefined;d.modal=a.modal!==false;if(a.title){d.setTitle(a.title||"&#160;")}if(Ext.isObject(a.buttons)){d.buttonText=a.buttons;c=0}else{d.buttonText=a.buttonText||d.buttonText;c=Ext.isNumber(a.buttons)?a.buttons:0}c=c|d.updateButtonText();d.buttonText=e;Ext.suspendLayouts();d.hidden=false;if(!d.rendered){d.width=g;d.render(Ext.getBody())}else{d.setSize(g,d.maxHeight)}d.closable=a.closable&&!a.wait;d.header.child("[type=close]").setVisible(a.closable!==false);if(!a.title&&!d.closable){d.header.hide()}else{d.header.show()}d.liveDrag=!a.proxyDrag;d.userCallback=Ext.Function.bind(a.callback||a.fn||Ext.emptyFn,a.scope||Ext.global);d.setIcon(a.icon);if(a.msg){d.msg.setValue(a.msg);d.msg.show()}else{d.msg.hide()}Ext.resumeLayouts(true);Ext.suspendLayouts();if(a.prompt||a.multiline){d.multiline=a.multiline;if(a.multiline){d.textArea.setValue(a.value);d.textArea.setHeight(a.defaultTextHeight||d.defaultTextHeight);d.textArea.show();d.textField.hide();d.defaultFocus=d.textArea}else{d.textField.setValue(a.value);d.textArea.hide();d.textField.show();d.defaultFocus=d.textField}}else{d.textArea.hide();d.textField.hide()}if(a.progress||a.wait){d.progressBar.show();d.updateProgress(0,a.progressText);if(a.wait===true){d.progressBar.wait(a.waitConfig)}}else{d.progressBar.hide()}for(b=0;b<4;b++){if(c&Math.pow(2,b)){if(!d.defaultFocus){d.defaultFocus=d.msgButtons[b]}d.msgButtons[b].show();h=false}else{d.msgButtons[b].hide()}}if(h){d.bottomTb.hide()}else{d.bottomTb.show()}Ext.resumeLayouts(true)},updateButtonText:function(){var d=this,c=d.buttonText,b=0,e,a;for(e in c){if(c.hasOwnProperty(e)){a=d.msgButtons[e];if(a){if(d.cfg&&d.cfg.buttonText){b=b|Math.pow(2,Ext.Array.indexOf(d.buttonIds,e))}if(a.text!=c[e]){a.setText(c[e])}}}}return b},show:function(a){var b=this;b.reconfigure(a);b.addCls(a.cls);b.doAutoSize();b.hidden=true;b.callParent();return b},onShow:function(){this.callParent(arguments);this.center()},doAutoSize:function(){var d=this,e=d.header.rendered&&d.header.isVisible(),c=d.bottomTb.rendered&&d.bottomTb.isVisible(),b,a;if(!Ext.isDefined(d.frameWidth)){d.frameWidth=d.el.getWidth()-d.body.getWidth()}d.minWidth=d.cfg.minWidth||Ext.getClass(this).prototype.minWidth;b=Math.max(e?d.header.getMinWidth():0,d.cfg.width||d.msg.getWidth()+d.iconComponent.getWidth()+25,(c?d.tbWidth:0));a=(e?d.header.getHeight():0)+d.topContainer.getHeight()+d.progressBar.getHeight()+(c?d.bottomTb.getHeight()+d.bottomTb.el.getMargin("tb"):0);d.setSize(b+d.frameWidth,a+d.frameWidth);return d},updateText:function(a){this.msg.setValue(a);return this.doAutoSize(true)},setIcon:function(a){var b=this;b.iconComponent.removeCls(b.messageIconCls);if(a){b.iconComponent.show();b.iconComponent.addCls(Ext.baseCSSPrefix+"dlg-icon");b.iconComponent.addCls(b.messageIconCls=a)}else{b.iconComponent.removeCls(Ext.baseCSSPrefix+"dlg-icon");b.iconComponent.hide()}return b},updateProgress:function(b,a,c){this.progressBar.updateProgress(b,a);if(c){this.updateText(c)}return this},onEsc:function(){if(this.closable!==false){this.callParent(arguments)}},confirm:function(a,d,c,b){if(Ext.isString(a)){a={title:a,icon:this.QUESTION,msg:d,buttons:this.YESNO,callback:c,scope:b}}return this.show(a)},prompt:function(b,g,d,c,a,e){if(Ext.isString(b)){b={prompt:true,title:b,minWidth:this.minPromptWidth,msg:g,buttons:this.OKCANCEL,callback:d,scope:c,multiline:a,value:e}}return this.show(b)},wait:function(a,c,b){if(Ext.isString(a)){a={title:c,msg:a,closable:false,wait:true,modal:true,minWidth:this.minProgressWidth,waitConfig:b}}return this.show(a)},alert:function(a,d,c,b){if(Ext.isString(a)){a={title:a,msg:d,buttons:this.OK,fn:c,scope:b,minWidth:this.minWidth}}return this.show(a)},progress:function(a,c,b){if(Ext.isString(a)){a={title:a,msg:c,progress:true,progressText:b}}return this.show(a)}},function(){Ext.MessageBox=Ext.Msg=new this()});Ext.define("Ext.form.Basic",{extend:"Ext.util.Observable",alternateClassName:"Ext.form.BasicForm",requires:["Ext.util.MixedCollection","Ext.form.action.Load","Ext.form.action.Submit","Ext.window.MessageBox","Ext.data.Errors","Ext.util.DelayedTask"],constructor:function(a,b){var e=this,g=e.onItemAddOrRemove,d,c;e.owner=a;e.mon(a,{add:g,remove:g,scope:e});Ext.apply(e,b);if(Ext.isString(e.paramOrder)){e.paramOrder=e.paramOrder.split(/[\s,|]/)}if(e.api){d=e.api=Ext.apply({},e.api);for(c in d){if(d.hasOwnProperty(c)){d[c]=Ext.direct.Manager.parseMethod(d[c])}}}e.checkValidityTask=new Ext.util.DelayedTask(e.checkValidity,e);e.addEvents("beforeaction","actionfailed","actioncomplete","validitychange","dirtychange");e.callParent()},initialize:function(){var a=this;a.initialized=true;a.onValidityChange(!a.hasInvalidField())},timeout:30,paramsAsHash:false,waitTitle:"Please Wait...",trackResetOnLoad:false,wasDirty:false,destroy:function(){this.clearListeners();this.checkValidityTask.cancel()},onItemAddOrRemove:function(c,g){var d=this,e=!!g.ownerCt,b=g.isContainer;function a(h){d[e?"mon":"mun"](h,{validitychange:d.checkValidity,dirtychange:d.checkDirty,scope:d,buffer:100});delete d._fields}if(g.isFormField){a(g)}else{if(b){if(g.isDestroyed||g.destroying){delete d._fields}else{Ext.Array.forEach(g.query("[isFormField]"),a)}}}delete this._boundItems;if(d.initialized){d.checkValidityTask.delay(10)}},getFields:function(){var a=this._fields;if(!a){a=this._fields=new Ext.util.MixedCollection();a.addAll(this.owner.query("[isFormField]"))}return a},getBoundItems:function(){var a=this._boundItems;if(!a||a.getCount()===0){a=this._boundItems=new Ext.util.MixedCollection();a.addAll(this.owner.query("[formBind]"))}return a},hasInvalidField:function(){return !!this.getFields().findBy(function(c){var a=c.preventMark,b;c.preventMark=true;b=c.isValid();c.preventMark=a;return !b})},isValid:function(){var a=this,b;Ext.suspendLayouts();b=a.getFields().filterBy(function(c){return !c.validate()});Ext.resumeLayouts(true);return b.length<1},checkValidity:function(){var b=this,a=!b.hasInvalidField();if(a!==b.wasValid){b.onValidityChange(a);b.fireEvent("validitychange",b,a);b.wasValid=a}},onValidityChange:function(g){var d=this.getBoundItems(),b,c,a,e;if(d){b=d.items;a=b.length;for(c=0;c<a;c++){e=b[c];if(e.disabled===g){e.setDisabled(!g)}}}},isDirty:function(){return !!this.getFields().findBy(function(a){return a.isDirty()})},checkDirty:function(){var a=this.isDirty();if(a!==this.wasDirty){this.fireEvent("dirtychange",this,a);this.wasDirty=a}},hasUpload:function(){return !!this.getFields().findBy(function(a){return a.isFileUpload()})},doAction:function(b,a){if(Ext.isString(b)){b=Ext.ClassManager.instantiateByAlias("formaction."+b,Ext.apply({},a,{form:this}))}if(this.fireEvent("beforeaction",this,b)!==false){this.beforeAction(b);Ext.defer(b.run,100,b)}return this},submit:function(a){a=a||{};var b=this,c;if(a.standardSubmit||b.standardSubmit){c="standardsubmit"}else{c=b.api?"directsubmit":"submit"}return b.doAction(c,a)},load:function(a){return this.doAction(this.api?"directload":"load",a)},updateRecord:function(c){c=c||this._record;var b=c.fields.items,d=this.getFieldValues(),h={},g=0,a=b.length,e;for(;g<a;++g){e=b[g].name;if(d.hasOwnProperty(e)){h[e]=d[e]}}c.beginEdit();c.set(h);c.endEdit();return this},loadRecord:function(a){this._record=a;return this.setValues(a.data)},getRecord:function(){return this._record},beforeAction:function(e){var b=e.waitMsg,d=Ext.baseCSSPrefix+"mask-loading",a=this.getFields().items,c,i=a.length,g,h;for(c=0;c<i;c++){g=a[c];if(g.isFormField&&g.syncValue){g.syncValue()}}if(b){h=this.waitMsgTarget;if(h===true){this.owner.el.mask(b,d)}else{if(h){h=this.waitMsgTarget=Ext.get(h);h.mask(b,d)}else{Ext.MessageBox.wait(b,e.waitTitle||this.waitTitle)}}}},afterAction:function(b,d){if(b.waitMsg){var a=Ext.MessageBox,c=this.waitMsgTarget;if(c===true){this.owner.el.unmask()}else{if(c){c.unmask()}else{a.suspendEvents();a.hide();a.resumeEvents()}}}if(d){if(b.reset){this.reset()}Ext.callback(b.success,b.scope||b,[this,b]);this.fireEvent("actioncomplete",this,b)}else{Ext.callback(b.failure,b.scope||b,[this,b]);this.fireEvent("actionfailed",this,b)}},findField:function(a){return this.getFields().findBy(function(b){return b.id===a||b.getName()===a})},markInvalid:function(j){var d=this,h,a,b,g,c;function i(e,l){var k=d.findField(e);if(k){k.markInvalid(l)}}if(Ext.isArray(j)){a=j.length;for(h=0;h<a;h++){b=j[h];i(b.id,b.msg)}}else{if(j instanceof Ext.data.Errors){a=j.items.length;for(h=0;h<a;h++){b=j.items[h];i(b.field,b.message)}}else{for(c in j){if(j.hasOwnProperty(c)){g=j[c];i(c,g,j)}}}}return this},setValues:function(b){var d=this,a,c,h,g;function e(i,k){var j=d.findField(i);if(j){j.setValue(k);if(d.trackResetOnLoad){j.resetOriginalValue()}}}if(Ext.isArray(b)){c=b.length;for(a=0;a<c;a++){h=b[a];e(h.id,h.value)}}else{Ext.iterate(b,e)}return this},getValues:function(i,j,n,l){var m={},g=this.getFields().items,h,o=g.length,e=Ext.isArray,k,d,c,b,a;for(h=0;h<o;h++){k=g[h];if(!j||k.isDirty()){d=k[l?"getModelData":"getSubmitData"](n);if(Ext.isObject(d)){for(a in d){if(d.hasOwnProperty(a)){c=d[a];if(n&&c===""){c=k.emptyText||""}if(m.hasOwnProperty(a)){b=m[a];if(!e(b)){b=m[a]=[b]}if(e(c)){m[a]=m[a]=b.concat(c)}else{b.push(c)}}else{m[a]=c}}}}}}if(i){m=Ext.Object.toQueryString(m)}return m},getFieldValues:function(a){return this.getValues(false,a,false,true)},clearInvalid:function(){Ext.suspendLayouts();var b=this,a=b.getFields().items,c,d=a.length;for(c=0;c<d;c++){a[c].clearInvalid()}Ext.resumeLayouts(true);return b},reset:function(){Ext.suspendLayouts();var b=this,a=b.getFields().items,c,d=a.length;for(c=0;c<d;c++){a[c].reset()}Ext.resumeLayouts(true);return b},applyToFields:function(c){var a=this.getFields().items,b,d=a.length;for(b=0;b<d;b++){Ext.apply(a[b],c)}return this},applyIfToFields:function(c){var a=this.getFields().items,b,d=a.length;for(b=0;b<d;b++){Ext.applyIf(a[b],c)}return this}});Ext.define("Ext.layout.container.CheckboxGroup",{extend:"Ext.layout.container.Container",alias:["layout.checkboxgroup"],autoFlex:true,type:"checkboxgroup",childEls:["innerCt"],renderTpl:['<table id="{ownerId}-innerCt" role="presentation" style="{tableStyle}"><tbody><tr>','<tpl for="columns">','<td class="{parent.colCls}" valign="top" style="{style}">',"{% this.renderColumn(out,parent,xindex-1) %}","</td>","</tpl>","</tr></tbody></table>"],lastOwnerItemsGeneration:null,beginLayout:function(b){var k=this,e,d,h,a,j,g=0,m=0,l=k.autoFlex,c=k.innerCt.dom.style;k.callParent(arguments);e=k.columnNodes;b.innerCtContext=b.getEl("innerCt",k);if(!b.widthModel.shrinkWrap){d=e.length;if(k.columnsArray){for(h=0;h<d;h++){a=k.owner.columns[h];if(a<1){g+=a;m++}}for(h=0;h<d;h++){a=k.owner.columns[h];if(a<1){j=((a/g)*100)+"%"}else{j=a+"px"}e[h].style.width=j}}else{for(h=0;h<d;h++){j=l?(1/d*100)+"%":"";e[h].style.width=j;m++}}if(!m){c.tableLayout="fixed";c.width=""}else{if(m<d){c.tableLayout="fixed";c.width="100%"}else{c.tableLayout="auto";if(l){c.width="100%"}else{c.width=""}}}}else{c.tableLayout="auto";c.width=""}},cacheElements:function(){var a=this;a.callParent();a.rowEl=a.innerCt.down("tr");a.columnNodes=a.rowEl.dom.childNodes},calculate:function(h){var e=this,c,b,a,i,d,g;if(!h.getDomProp("containerChildrenDone")){e.done=false}else{c=h.innerCtContext;b=h.widthModel.shrinkWrap;a=h.heightModel.shrinkWrap;i=a||b;d=c.el.dom;g=i&&c.getPaddingInfo();if(b){h.setContentWidth(d.offsetWidth+g.width,true)}if(a){h.setContentHeight(d.offsetHeight+g.height,true)}}},doRenderColumn:function(d,l,g){var i=l.$layout,c=i.owner,e=l.columnCount,h=c.items.items,b=h.length,m,a,j,k,n;if(c.vertical){j=Math.ceil(b/e);a=g*j;b=Math.min(b,a+j);k=1}else{a=g;k=e}for(;a<b;a+=k){m=h[a];i.configureItem(m);n=m.getRenderTree();Ext.DomHelper.generateMarkup(n,d)}},getColumnCount:function(){var b=this,a=b.owner,c=a.columns;if(b.columnsArray){return c.length}if(Ext.isNumber(c)){return c}return a.items.length},getItemSizePolicy:function(a){return this.autoSizePolicy},getRenderData:function(){var k=this,g=k.callParent(),b=k.owner,h,d=k.getColumnCount(),a,c,j,l=k.autoFlex,e=0,m=0;if(k.columnsArray){for(h=0;h<d;h++){a=k.owner.columns[h];if(a<1){e+=a;m++}}}g.colCls=b.groupCls;g.columnCount=d;g.columns=[];for(h=0;h<d;h++){c=(g.columns[h]={});if(k.columnsArray){a=k.owner.columns[h];if(a<1){j=((a/e)*100)+"%"}else{j=a+"px"}c.style="width:"+j}else{c.style="width:"+(1/d*100)+"%";m++}}g.tableStyle=!m?"table-layout:fixed;":(m<d)?"table-layout:fixed;width:100%":(l)?"table-layout:auto;width:100%":"table-layout:auto;";return g},initLayout:function(){var b=this,a=b.owner;b.columnsArray=Ext.isArray(a.columns);b.autoColumns=!a.columns||a.columns==="auto";b.vertical=a.vertical;b.callParent()},isValidParent:function(){return true},setupRenderTpl:function(a){this.callParent(arguments);a.renderColumn=this.doRenderColumn},renderChildren:function(){var a=this,b=a.owner.items.generation;if(a.lastOwnerItemsGeneration!==b){a.lastOwnerItemsGeneration=b;a.renderItems(a.getLayoutItems())}},renderItems:function(e){var g=this,a=e.length,b,k,j,d,h,c;if(a){Ext.suspendLayouts();if(g.autoColumns){g.addMissingColumns(a)}d=g.columnNodes.length;j=Math.ceil(a/d);for(b=0;b<a;b++){k=e[b];h=g.getRenderRowIndex(b,j,d);c=g.getRenderColumnIndex(b,j,d);if(!k.rendered){g.renderItem(k,h,c)}else{if(!g.isItemAtPosition(k,h,c)){g.moveItem(k,h,c)}}}if(g.autoColumns){g.removeExceedingColumns(a)}Ext.resumeLayouts(true)}},isItemAtPosition:function(b,c,a){return b.el.dom===this.getNodeAt(c,a)},getRenderColumnIndex:function(b,a,c){if(this.vertical){return Math.floor(b/a)}else{return b%c}},getRenderRowIndex:function(b,a,d){var c=this;if(c.vertical){return b%a}else{return Math.floor(b/d)}},getNodeAt:function(b,a){return this.columnNodes[a].childNodes[b]},addMissingColumns:function(a){var g=this,c=g.columnNodes.length,e,h,b,d;if(c<a){e=a-c;h=g.rowEl;b=g.owner.groupCls;for(d=0;d<e;d++){h.createChild({cls:b,tag:"td",vAlign:"top"})}}},removeExceedingColumns:function(a){var e=this,b=e.columnNodes.length,d,g,c;if(b>a){d=b-a;g=e.rowEl;for(c=0;c<d;c++){g.last().remove()}}},renderItem:function(c,d,a){var b=this;b.configureItem(c);c.render(Ext.get(b.columnNodes[a]),d);b.afterRenderItem(c)},moveItem:function(d,g,b){var c=this,a=c.columnNodes[b],e=a.childNodes[g];a.insertBefore(d.el.dom,e||null)}});Ext.define("Ext.layout.component.field.FieldContainer",{extend:"Ext.layout.component.field.Field",alias:"layout.fieldcontainer",type:"fieldcontainer",waitForOuterHeightInDom:true,waitForOuterWidthInDom:true,beginLayout:function(a){this.callParent(arguments);a.hasRawContent=true;a.target.bodyEl.setStyle("height","")},measureContentHeight:function(a){return a.hasDomProp("containerLayoutDone")?this.callParent(arguments):NaN},measureContentWidth:function(a){return a.hasDomProp("containerLayoutDone")?this.callParent(arguments):NaN},publishInnerWidth:function(b,a){var c=b.bodyCellContext;c.setWidth(c.el.getWidth(),false)},publishInnerHeight:function(b,a){var c=b.bodyCellContext;c.setHeight(a-this.measureLabelErrorHeight(b))}});Ext.define("Ext.form.FieldAncestor",{initFieldAncestor:function(){var a=this,b=a.onFieldAncestorSubtreeChange;a.addEvents("fieldvaliditychange","fielderrorchange");a.on("add",b,a);a.on("remove",b,a);a.initFieldDefaults()},initFieldDefaults:function(){if(!this.fieldDefaults){this.fieldDefaults={}}},onFieldAncestorSubtreeChange:function(b,e){var c=this,d=!!e.ownerCt;function a(g){var h=g.isFieldLabelable,i=g.isFormField;if(h||i){if(h){c["onLabelable"+(d?"Added":"Removed")](g)}if(i){c["onField"+(d?"Added":"Removed")](g)}}else{if(g.isContainer){Ext.Array.forEach(g.getRefItems(),a)}}}a(e)},onLabelableAdded:function(a){var b=this;b.mon(a,"errorchange",b.handleFieldErrorChange,b,{buffer:10});a.setFieldDefaults(b.fieldDefaults)},onFieldAdded:function(b){var a=this;a.mon(b,"validitychange",a.handleFieldValidityChange,a)},onLabelableRemoved:function(a){var b=this;b.mun(a,"errorchange",b.handleFieldErrorChange,b)},onFieldRemoved:function(b){var a=this;a.mun(b,"validitychange",a.handleFieldValidityChange,a)},handleFieldValidityChange:function(c,b){var a=this;a.fireEvent("fieldvaliditychange",a,c,b);a.onFieldValidityChange(c,b)},handleFieldErrorChange:function(b,a){var c=this;c.fireEvent("fielderrorchange",c,b,a);c.onFieldErrorChange(b,a)},onFieldValidityChange:Ext.emptyFn,onFieldErrorChange:Ext.emptyFn});Ext.define("Ext.form.FieldContainer",{extend:"Ext.container.Container",mixins:{labelable:"Ext.form.Labelable",fieldAncestor:"Ext.form.FieldAncestor"},requires:"Ext.layout.component.field.FieldContainer",alias:"widget.fieldcontainer",componentLayout:"fieldcontainer",componentCls:Ext.baseCSSPrefix+"form-fieldcontainer",combineLabels:false,labelConnector:", ",combineErrors:false,maskOnDisable:false,fieldSubTpl:"{%this.renderContainer(out,values)%}",initComponent:function(){var a=this;a.initLabelable();a.initFieldAncestor();a.callParent()},beforeRender:function(){this.callParent(arguments);this.beforeLabelableRender(arguments)},onLabelableAdded:function(a){var b=this;b.mixins.fieldAncestor.onLabelableAdded.call(this,a);b.updateLabel()},onLabelableRemoved:function(a){var b=this;b.mixins.fieldAncestor.onLabelableRemoved.call(this,a);b.updateLabel()},initRenderTpl:function(){var a=this;if(!a.hasOwnProperty("renderTpl")){a.renderTpl=a.getTpl("labelableRenderTpl")}return a.callParent()},initRenderData:function(){return Ext.applyIf(this.callParent(),this.getLabelableRenderData())},getFieldLabel:function(){var a=this.fieldLabel||"";if(!a&&this.combineLabels){a=Ext.Array.map(this.query("[isFieldLabelable]"),function(b){return b.getFieldLabel()}).join(this.labelConnector)}return a},getSubTplData:function(){var a=this.initRenderData();Ext.apply(a,this.subTplData);return a},getSubTplMarkup:function(){var c=this,a=c.getTpl("fieldSubTpl"),b;if(!a.renderContent){c.setupRenderTpl(a)}b=a.apply(c.getSubTplData());return b},updateLabel:function(){var b=this,a=b.labelEl;if(a){b.setFieldLabel(b.getFieldLabel())}},onFieldErrorChange:function(e,b){if(this.combineErrors){var d=this,g=d.getActiveError(),c=Ext.Array.filter(d.query("[isFormField]"),function(h){return h.hasActiveError()}),a=d.getCombinedErrors(c);if(a){d.setActiveErrors(a)}else{d.unsetActiveError()}if(g!==d.getActiveError()){d.doComponentLayout()}}},getCombinedErrors:function(e){var k=[],c,l=e.length,i,d,j,b,g,h;for(c=0;c<l;c++){i=e[c];d=i.getActiveErrors();b=d.length;for(j=0;j<b;j++){g=d[j];h=i.getFieldLabel();k.push((h?h+": ":"")+g)}}return k},getTargetEl:function(){return this.bodyEl||this.callParent()}});Ext.define("Ext.form.CheckboxGroup",{extend:"Ext.form.FieldContainer",mixins:{field:"Ext.form.field.Field"},alias:"widget.checkboxgroup",requires:["Ext.layout.container.CheckboxGroup","Ext.form.field.Base"],columns:"auto",vertical:false,allowBlank:true,blankText:"You must select at least one item in this group",defaultType:"checkboxfield",groupCls:Ext.baseCSSPrefix+"form-check-group",fieldBodyCls:Ext.baseCSSPrefix+"form-checkboxgroup-body",layout:"checkboxgroup",initComponent:function(){var a=this;a.callParent();a.initField()},initValue:function(){var b=this,a=b.value;b.originalValue=b.lastValue=a||b.getValue();if(a){b.setValue(a)}},onFieldAdded:function(b){var a=this;if(b.isCheckbox){a.mon(b,"change",a.checkChange,a)}a.callParent(arguments)},onFieldRemoved:function(b){var a=this;if(b.isCheckbox){a.mun(b,"change",a.checkChange,a)}a.callParent(arguments)},isEqual:function(b,a){var c=Ext.Object.toQueryString;return c(b)===c(a)},getErrors:function(){var a=[];if(!this.allowBlank&&Ext.isEmpty(this.getChecked())){a.push(this.blankText)}return a},getBoxes:function(a){return this.query("[isCheckbox]"+(a||""))},eachBox:function(b,a){Ext.Array.forEach(this.getBoxes(),b,a||this)},getChecked:function(){return this.getBoxes("[checked]")},isDirty:function(){var c=this.getBoxes(),a,d=c.length;for(a=0;a<d;a++){if(c[a].isDirty()){return true}}},setReadOnly:function(e){var c=this.getBoxes(),a,d=c.length;for(a=0;a<d;a++){c[a].setReadOnly(e)}this.readOnly=e},reset:function(){var c=this,b=c.hasActiveError(),a=c.preventMark;c.preventMark=true;c.batchChanges(function(){var e=c.getBoxes(),d,g=e.length;for(d=0;d<g;d++){e[d].reset()}});c.preventMark=a;c.unsetActiveError();if(b){c.updateLayout()}},resetOriginalValue:function(){var d=this,c=d.getBoxes(),a,e=c.length;for(a=0;a<e;a++){c[a].resetOriginalValue()}d.originalValue=d.getValue();d.checkDirty()},setValue:function(h){var g=this,d=g.getBoxes(),a,j=d.length,e,c,i;g.batchChanges(function(){for(a=0;a<j;a++){e=d[a];c=e.getName();i=false;if(h&&h.hasOwnProperty(c)){if(Ext.isArray(h[c])){i=Ext.Array.contains(h[c],e.inputValue)}else{i=h[c]}}e.setValue(i)}});return g},getValue:function(){var d={},g=this.getBoxes(),c,j=g.length,h,e,a,i;for(c=0;c<j;c++){h=g[c];e=h.getName();a=h.inputValue;if(h.getValue()){if(d.hasOwnProperty(e)){i=d[e];if(!Ext.isArray(i)){i=d[e]=[i]}i.push(a)}else{d[e]=a}}}return d},getSubmitData:function(){return null},getModelData:function(){return null},validate:function(){var a=this,d,c,b;if(a.disabled){c=true}else{d=a.getErrors();c=Ext.isEmpty(d);b=!a.hasActiveError();if(c){a.unsetActiveError()}else{a.setActiveError(d)}}if(c!==b){a.fireEvent("validitychange",a,c);a.updateLayout()}return c}},function(){this.borrow(Ext.form.field.Base,["markInvalid","clearInvalid"])});Ext.define("Ext.form.CheckboxManager",{extend:"Ext.util.MixedCollection",singleton:true,getByName:function(a){return this.filterBy(function(b){return b.name==a})},getWithValue:function(a,b){return this.filterBy(function(c){return c.name==a&&c.inputValue==b})},getChecked:function(a){return this.filterBy(function(b){return b.name==a&&b.checked})}});Ext.define("Ext.layout.component.FieldSet",{extend:"Ext.layout.component.Body",alias:["layout.fieldset"],type:"fieldset",beforeLayoutCycle:function(a){if(a.target.collapsed){a.heightModel=this.sizeModels.shrinkWrap}},beginLayoutCycle:function(b){var c=b.target,a;this.callParent(arguments);if(c.collapsed){b.setContentHeight(0);if(b.widthModel.shrinkWrap){a=c.lastComponentSize;b.setContentWidth((a&&a.contentWidth)||100)}}},calculateOwnerHeightFromContentHeight:function(d,c){var a=d.getBorderInfo(),b=d.target.legend;return d.getProp("contentHeight")+d.getPaddingInfo().height+(b?b.getHeight():a.top)+a.bottom},publishInnerHeight:function(c,a){var b=c.target.legend;if(b){a-=b.getHeight()}this.callParent([c,a])},getLayoutItems:function(){var a=this.owner.legend;if(a){return[a]}return[]}});Ext.define("Ext.form.FieldSet",{extend:"Ext.container.Container",alias:"widget.fieldset",uses:["Ext.form.field.Checkbox","Ext.panel.Tool","Ext.layout.container.Anchor","Ext.layout.component.FieldSet"],collapsed:false,toggleOnTitleClick:true,baseCls:Ext.baseCSSPrefix+"fieldset",layout:"anchor",border:1,componentLayout:"fieldset",autoEl:"fieldset",childEls:["body"],renderTpl:["{%this.renderLegend(out,values);%}",'<div id="{id}-body" class="{baseCls}-body">',"{%this.renderContainer(out,values);%}","</div>"],stateEvents:["collapse","expand"],maskOnDisable:false,beforeDestroy:function(){var b=this,a=b.legend;if(a){delete a.ownerCt;a.destroy();b.legend=null}b.callParent()},initComponent:function(){var b=this,a=b.baseCls;b.callParent();b.addEvents("beforeexpand","beforecollapse","expand","collapse");if(b.collapsed){b.addCls(a+"-collapsed");b.collapse()}if(b.title){b.addCls(a+"-with-title")}if(b.title||b.checkboxToggle||b.collapsible){b.addCls(a+"-with-legend");b.legend=Ext.widget(b.createLegendCt())}},initRenderData:function(){var a=this.callParent();a.baseCls=this.baseCls;return a},getState:function(){var a=this.callParent();a=this.addPropertyToState(a,"collapsed");return a},afterCollapse:Ext.emptyFn,afterExpand:Ext.emptyFn,collapsedHorizontal:function(){return true},collapsedVertical:function(){return true},createLegendCt:function(){var c=this,a=[],b={xtype:"container",baseCls:c.baseCls+"-header",id:c.id+"-legend",autoEl:"legend",items:a,ownerCt:c,ownerLayout:c.componentLayout};if(c.checkboxToggle){a.push(c.createCheckboxCmp())}else{if(c.collapsible){a.push(c.createToggleCmp())}}a.push(c.createTitleCmp());return b},createTitleCmp:function(){var b=this,a={xtype:"component",html:b.title,cls:b.baseCls+"-header-text",id:b.id+"-legendTitle"};if(b.collapsible&&b.toggleOnTitleClick){a.listeners={el:{scope:b,click:b.toggle}};a.cls+=" "+b.baseCls+"-header-text-collapsible"}return(b.titleCmp=Ext.widget(a))},createCheckboxCmp:function(){var a=this,b="-checkbox";a.checkboxCmp=Ext.widget({xtype:"checkbox",hideEmptyLabel:true,name:a.checkboxName||a.id+b,cls:a.baseCls+"-header"+b,id:a.id+"-legendChk",checked:!a.collapsed,listeners:{change:a.onCheckChange,scope:a}});return a.checkboxCmp},createToggleCmp:function(){var a=this;a.toggleCmp=Ext.widget({xtype:"tool",type:"toggle",handler:a.toggle,id:a.id+"-legendToggle",scope:a});return a.toggleCmp},doRenderLegend:function(b,e){var d=e.$comp,c=d.legend,a;if(c){c.ownerLayout.configureItem(c);a=c.getRenderTree();Ext.DomHelper.generateMarkup(a,b)}},finishRender:function(){var a=this.legend;this.callParent();if(a){a.finishRender()}},getCollapsed:function(){return this.collapsed?"top":false},getCollapsedDockedItems:function(){var a=this.legend;return a?[a]:[]},setTitle:function(c){var b=this,a=b.legend;b.title=c;if(b.rendered){if(!b.legend){b.legend=a=Ext.widget(b.createLegendCt());a.ownerLayout.configureItem(a);a.render(b.el,0)}b.titleCmp.update(c)}return b},getTargetEl:function(){return this.body||this.frameBody||this.el},getContentTarget:function(){return this.body},expand:function(){return this.setExpanded(true)},collapse:function(){return this.setExpanded(false)},setExpanded:function(b){var c=this,d=c.checkboxCmp,a=b?"expand":"collapse";if(!c.rendered||c.fireEvent("before"+a,c)!==false){b=!!b;if(d){d.setValue(b)}if(b){c.removeCls(c.baseCls+"-collapsed")}else{c.addCls(c.baseCls+"-collapsed")}c.collapsed=!b;if(c.rendered){c.updateLayout({isRoot:false});c.fireEvent(a,c)}}return c},getRefItems:function(a){var c=this.callParent(arguments),b=this.legend;if(b){c.unshift(b);if(a){c.unshift.apply(c,b.getRefItems(true))}}return c},toggle:function(){this.setExpanded(!!this.collapsed)},onCheckChange:function(b,a){this.setExpanded(a)},setupRenderTpl:function(a){this.callParent(arguments);a.renderLegend=this.doRenderLegend}});Ext.define("Ext.form.Label",{extend:"Ext.Component",alias:"widget.label",requires:["Ext.util.Format"],autoEl:"label",maskOnDisable:false,getElConfig:function(){var a=this;a.html=a.text?Ext.util.Format.htmlEncode(a.text):(a.html||"");return Ext.apply(a.callParent(),{htmlFor:a.forId||""})},setText:function(c,b){var a=this;b=b!==false;if(b){a.text=c;delete a.html}else{a.html=c;delete a.text}if(a.rendered){a.el.dom.innerHTML=b!==false?Ext.util.Format.htmlEncode(c):c;a.updateLayout()}return a}});Ext.define("Ext.form.Panel",{extend:"Ext.panel.Panel",mixins:{fieldAncestor:"Ext.form.FieldAncestor"},alias:"widget.form",alternateClassName:["Ext.FormPanel","Ext.form.FormPanel"],requires:["Ext.form.Basic","Ext.util.TaskRunner"],layout:"anchor",ariaRole:"form",basicFormConfigs:["api","baseParams","errorReader","method","paramOrder","paramsAsHash","reader","standardSubmit","timeout","trackResetOnLoad","url","waitMsgTarget","waitTitle"],initComponent:function(){var a=this;if(a.frame){a.border=false}a.initFieldAncestor();a.callParent();a.relayEvents(a.form,["beforeaction","actionfailed","actioncomplete","validitychange","dirtychange"]);if(a.pollForChanges){a.startPolling(a.pollInterval||500)}},initItems:function(){var a=this;a.form=a.createForm();a.callParent()},afterFirstLayout:function(){this.callParent();this.form.initialize()},createForm:function(){var b={},d=this.basicFormConfigs,a=d.length,c=0,e;for(;c<a;++c){e=d[c];b[e]=this[e]}return new Ext.form.Basic(this,b)},getForm:function(){return this.form},loadRecord:function(a){return this.getForm().loadRecord(a)},getRecord:function(){return this.getForm().getRecord()},getValues:function(d,b,c,a){return this.getForm().getValues(d,b,c,a)},beforeDestroy:function(){this.stopPolling();this.form.destroy();this.callParent()},load:function(a){this.form.load(a)},submit:function(a){this.form.submit(a)},startPolling:function(b){this.stopPolling();var a=new Ext.util.TaskRunner(b);a.start({interval:0,run:this.checkChange,scope:this});this.pollTask=a},stopPolling:function(){var a=this.pollTask;if(a){a.stopAll();delete this.pollTask}},checkChange:function(){var a=this.form.getFields().items,b,d=a.length,c;for(b=0;b<d;b++){a[b].checkChange()}}});Ext.define("Ext.form.RadioGroup",{extend:"Ext.form.CheckboxGroup",alias:"widget.radiogroup",allowBlank:true,blankText:"You must select one item in this group",defaultType:"radiofield",groupCls:Ext.baseCSSPrefix+"form-radio-group",getBoxes:function(a){return this.query("[isRadio]"+(a||""))},checkChange:function(){var b=this.getValue(),a=Ext.Object.getKeys(b)[0];if(Ext.isArray(b[a])){return}this.callParent(arguments)},setValue:function(d){var j,g,e,h,c,a,b;if(Ext.isObject(d)){for(b in d){if(d.hasOwnProperty(b)){j=d[b];g=this.items.first();e=g?g.getFormId():null;h=Ext.form.RadioManager.getWithValue(b,j,e).items;a=h.length;for(c=0;c<a;++c){h[c].setValue(true)}}}}return this}});Ext.define("Ext.form.RadioManager",{extend:"Ext.util.MixedCollection",singleton:true,getByName:function(a,b){return this.filterBy(function(c){return c.name==a&&c.getFormId()==b})},getWithValue:function(a,b,c){return this.filterBy(function(d){return d.name==a&&d.inputValue==b&&d.getFormId()==c})},getChecked:function(a,b){return this.findBy(function(c){return c.name==a&&c.checked&&c.getFormId()==b})}});Ext.define("Ext.form.action.DirectLoad",{extend:"Ext.form.action.Load",requires:["Ext.direct.Manager"],alternateClassName:"Ext.form.Action.DirectLoad",alias:"formaction.directload",type:"directload",run:function(){var d=this,c=d.form,b=c.api.load,e=b.directCfg.method,a=e.getArgs(d.getParams(),c.paramOrder,c.paramsAsHash);a.push(d.onComplete,d);b.apply(window,a)},processResponse:function(a){return(this.result=a)},onComplete:function(b,a){if(b){this.onSuccess(b)}else{this.onFailure(null)}}});Ext.define("Ext.form.action.DirectSubmit",{extend:"Ext.form.action.Submit",requires:["Ext.direct.Manager"],alternateClassName:"Ext.form.Action.DirectSubmit",alias:"formaction.directsubmit",type:"directsubmit",doSubmit:function(){var b=this,c=Ext.Function.bind(b.onComplete,b),a=b.buildForm();b.form.api.submit(a,c,b);Ext.removeNode(a)},processResponse:function(a){return(this.result=a)},onComplete:function(b,a){if(b){this.onSuccess(b)}else{this.onFailure(null)}}});Ext.define("Ext.form.action.StandardSubmit",{extend:"Ext.form.action.Submit",alias:"formaction.standardsubmit",doSubmit:function(){var a=this.buildForm();a.submit();Ext.removeNode(a)}});Ext.define("Ext.form.field.Checkbox",{extend:"Ext.form.field.Base",alias:["widget.checkboxfield","widget.checkbox"],alternateClassName:"Ext.form.Checkbox",requires:["Ext.XTemplate","Ext.form.CheckboxManager"],componentLayout:"field",childEls:["boxLabelEl"],fieldSubTpl:["<tpl if=\"boxLabel && boxLabelAlign == 'before'\">","{beforeBoxLabelTpl}",'<label id="{cmpId}-boxLabelEl" {boxLabelAttrTpl} class="{boxLabelCls} {boxLabelCls}-{boxLabelAlign}" for="{id}">',"{beforeBoxLabelTextTpl}","{boxLabel}","{afterBoxLabelTextTpl}","</label>","{afterBoxLabelTpl}","</tpl>",'<input type="button" id="{id}" {inputAttrTpl}','<tpl if="tabIdx"> tabIndex="{tabIdx}"</tpl>','<tpl if="disabled"> disabled="disabled"</tpl>','<tpl if="fieldStyle"> style="{fieldStyle}"</tpl>',' class="{fieldCls} {typeCls}" autocomplete="off" hidefocus="true" />',"<tpl if=\"boxLabel && boxLabelAlign == 'after'\">","{beforeBoxLabelTpl}",'<label id="{cmpId}-boxLabelEl" {boxLabelAttrTpl} class="{boxLabelCls} {boxLabelCls}-{boxLabelAlign}" for="{id}">',"{beforeBoxLabelTextTpl}","{boxLabel}","{afterBoxLabelTextTpl}","</label>","{afterBoxLabelTpl}","</tpl>",{disableFormats:true,compiled:true}],subTplInsertions:["beforeBoxLabelTpl","afterBoxLabelTpl","beforeBoxLabelTextTpl","afterBoxLabelTextTpl","boxLabelAttrTpl","inputAttrTpl"],isCheckbox:true,focusCls:"form-cb-focus",fieldBodyCls:Ext.baseCSSPrefix+"form-cb-wrap",checked:false,checkedCls:Ext.baseCSSPrefix+"form-cb-checked",boxLabelCls:Ext.baseCSSPrefix+"form-cb-label",boxLabelAlign:"after",inputValue:"on",checkChangeEvents:[],inputType:"checkbox",onRe:/^on$/i,initComponent:function(){this.callParent(arguments);this.getManager().add(this)},initValue:function(){var b=this,a=!!b.checked;b.originalValue=b.lastValue=a;b.setValue(a)},getElConfig:function(){var a=this;if(a.isChecked(a.rawValue,a.inputValue)){a.addCls(a.checkedCls)}return a.callParent()},getFieldStyle:function(){return Ext.isObject(this.fieldStyle)?Ext.DomHelper.generateStyles(this.fieldStyle):this.fieldStyle||""},getSubTplData:function(){var a=this;return Ext.apply(a.callParent(),{disabled:a.readOnly||a.disabled,boxLabel:a.boxLabel,boxLabelCls:a.boxLabelCls,boxLabelAlign:a.boxLabelAlign})},initEvents:function(){var a=this;a.callParent();a.mon(a.inputEl,"click",a.onBoxClick,a)},onBoxClick:function(b){var a=this;if(!a.disabled&&!a.readOnly){this.setValue(!this.checked)}},getRawValue:function(){return this.checked},getValue:function(){return this.checked},getSubmitValue:function(){var a=this.uncheckedValue,b=Ext.isDefined(a)?a:null;return this.checked?this.inputValue:b},isChecked:function(b,a){return(b===true||b==="true"||b==="1"||b===1||(((Ext.isString(b)||Ext.isNumber(b))&&a)?b==a:this.onRe.test(b)))},setRawValue:function(c){var b=this,d=b.inputEl,a=b.isChecked(c,b.inputValue);if(d){b[a?"addCls":"removeCls"](b.checkedCls)}b.checked=b.rawValue=a;return a},setValue:function(g){var e=this,c,b,a,d;if(Ext.isArray(g)){c=e.getManager().getByName(e.name,e.getFormId()).items;a=c.length;for(b=0;b<a;++b){d=c[b];d.setValue(Ext.Array.contains(g,d.inputValue))}}else{e.callParent(arguments)}return e},valueToRaw:function(a){return a},onChange:function(b,a){var d=this,c=d.handler;if(c){c.call(d.scope||d,d,b)}d.callParent(arguments)},resetOriginalValue:function(b){var g=this,d,e,a,c;if(!b){d=g.getManager().getByName(g.name,g.getFormId()).items;a=d.length;for(c=0;c<a;++c){e=d[c];if(e!==g){d[c].resetOriginalValue(true)}}}g.callParent()},beforeDestroy:function(){this.callParent();this.getManager().removeAtKey(this.id)},getManager:function(){return Ext.form.CheckboxManager},onEnable:function(){var a=this,b=a.inputEl;a.callParent();if(b){b.dom.disabled=a.readOnly}},setReadOnly:function(c){var a=this,b=a.inputEl;if(b){b.dom.disabled=!!c||a.disabled}a.callParent(arguments)},getFormId:function(){var b=this,a;if(!b.formId){a=b.up("form");if(a){b.formId=a.id}}return b.formId}});Ext.define("Ext.layout.component.field.Trigger",{alias:"layout.triggerfield",extend:"Ext.layout.component.field.Field",type:"triggerfield",beginLayout:function(d){var c=this,a=c.owner,b;d.triggerWrap=d.getEl("triggerWrap");c.callParent(arguments);b=a.getTriggerStateFlags();if(b!=a.lastTriggerStateFlags){a.lastTriggerStateFlags=b;c.updateEditState()}},beginLayoutFixed:function(g,c,h){var d=this,a=g.target,e=d.ieInputWidthAdjustment||0,i="100%",b=a.triggerWrap;d.callParent(arguments);a.inputCell.setStyle("width","100%");if(e){a.inputCell.setStyle("padding-right",e+"px");if(h==="px"){if(a.inputWidth){i=a.inputWidth-a.getTriggerWidth()}else{i=c-e-a.getTriggerWidth()}i+="px"}}a.inputEl.setStyle("width",i);i=a.inputWidth;if(i){b.setStyle("width",i+(e)+"px")}else{b.setStyle("width",c+h)}b.setStyle("table-layout","fixed")},beginLayoutShrinkWrap:function(d){var a=d.target,g="",e=a.inputWidth,b=a.triggerWrap,c=this.ieInputWidthAdjustment||0;this.callParent(arguments);if(e){b.setStyle("width",e+"px");e=(e-a.getTriggerWidth())+"px";a.inputEl.setStyle("width",e);a.inputCell.setStyle("width",e)}else{a.inputCell.setStyle("width",g);a.inputEl.setStyle("width",g);b.setStyle("width",g);b.setStyle("table-layout","auto")}},getTextWidth:function(){var b=this,a=b.owner,d=a.inputEl,c;c=(d.dom.value||(a.hasFocus?"":a.emptyText)||"")+a.growAppend;return d.getTextWidth(c)},measureContentWidth:function(h){var g=this,b=g.owner,e=g.callParent(arguments),i=h.inputContext,d,a,c;if(b.grow&&!h.state.growHandled){d=g.getTextWidth()+h.inputContext.getFrameInfo().width;a=b.growMax;c=Math.min(a,e);a=Math.max(b.growMin,a,c);d=Ext.Number.constrain(d,b.growMin,a);i.setWidth(d);h.state.growHandled=true;i.domBlock(g,"width");e=NaN}return e},updateEditState:function(){var c=this,a=c.owner,e=a.inputEl,d=Ext.baseCSSPrefix+"trigger-noedit",b,g;if(c.owner.readOnly){e.addCls(d);g=true;b=false}else{if(c.owner.editable){e.removeCls(d);g=false}else{e.addCls(d);g=true}b=!c.owner.hideTrigger}a.triggerCell.setDisplayed(b);e.dom.readOnly=g}});Ext.define("Ext.layout.component.field.ComboBox",{extend:"Ext.layout.component.field.Trigger",alias:"layout.combobox",requires:["Ext.util.TextMetrics"],type:"combobox",startingWidth:null,getTextWidth:function(){var h=this,b=h.owner,l=b.store,j=b.displayField,d=l.data.length,k="",e=0,c=0,g,m,a;for(;e<d;e++){m=l.getAt(e).data[j];g=m.length;if(g>c){c=g;k=m}}a=Math.max(h.callParent(arguments),b.inputEl.getTextWidth(k+b.growAppend));if(!h.startingWidth||b.removingRecords){h.startingWidth=a;if(a<b.growMin){b.defaultListConfig.minWidth=b.growMin}b.removingRecords=false}return(a<h.startingWidth)?h.startingWidth:a}});Ext.define("Ext.form.field.Trigger",{extend:"Ext.form.field.Text",alias:["widget.triggerfield","widget.trigger"],requires:["Ext.DomHelper","Ext.util.ClickRepeater","Ext.layout.component.field.Trigger"],alternateClassName:["Ext.form.TriggerField","Ext.form.TwinTriggerField","Ext.form.Trigger"],childEls:[{name:"triggerCell",select:"."+Ext.baseCSSPrefix+"trigger-cell"},{name:"triggerEl",select:"."+Ext.baseCSSPrefix+"form-trigger"},"triggerWrap","inputCell"],triggerBaseCls:Ext.baseCSSPrefix+"form-trigger",triggerWrapCls:Ext.baseCSSPrefix+"form-trigger-wrap",triggerNoEditCls:Ext.baseCSSPrefix+"trigger-noedit",hideTrigger:false,editable:true,readOnly:false,repeatTriggerClick:false,autoSize:Ext.emptyFn,monitorTab:true,mimicing:false,triggerIndexRe:/trigger-index-(\d+)/,componentLayout:"triggerfield",initComponent:function(){this.wrapFocusCls=this.triggerWrapCls+"-focus";this.callParent(arguments)},getSubTplMarkup:function(){var a=this,b=a.callParent(arguments);return'<table id="'+a.id+'-triggerWrap" class="'+Ext.baseCSSPrefix+'form-trigger-wrap" cellpadding="0" cellspacing="0"><tbody><tr><td id="'+a.id+'-inputCell" class="'+Ext.baseCSSPrefix+'form-trigger-input-cell">'+b+"</td>"+a.getTriggerMarkup()+"</tr></tbody></table>"},getSubTplData:function(){var b=this,c=b.callParent(),d=b.readOnly===true,a=b.editable!==false;return Ext.apply(c,{editableCls:(d||!a)?" "+b.triggerNoEditCls:"",readOnly:!a||d})},getLabelableRenderData:function(){var b=this,c=b.triggerWrapCls,a=b.callParent(arguments);return Ext.applyIf(a,{triggerWrapCls:c,triggerMarkup:b.getTriggerMarkup()})},getTriggerMarkup:function(){var c=this,b=0,d=(c.readOnly||c.hideTrigger),g,e=c.triggerBaseCls,a=[];if(!c.trigger1Cls){c.trigger1Cls=c.triggerCls}for(b=0;(g=c["trigger"+(b+1)+"Cls"])||b<1;b++){a.push({tag:"td",valign:"top",cls:Ext.baseCSSPrefix+"trigger-cell",style:"width:"+c.triggerWidth+(d?"px;display:none":"px"),cn:{cls:[Ext.baseCSSPrefix+"trigger-index-"+b,e,g].join(" "),role:"button"}})}a[b-1].cn.cls+=" "+e+"-last";return Ext.DomHelper.markup(a)},disableCheck:function(){return !this.disabled},beforeRender:function(){var a=this,b=a.triggerBaseCls,c;if(!a.triggerWidth){c=Ext.resetElement.createChild({style:"position: absolute;",cls:Ext.baseCSSPrefix+"form-trigger"});Ext.form.field.Trigger.prototype.triggerWidth=c.getWidth();c.remove()}a.callParent();if(b!=Ext.baseCSSPrefix+"form-trigger"){a.addChildEls({name:"triggerEl",select:"."+b})}a.lastTriggerStateFlags=a.getTriggerStateFlags()},onRender:function(){var a=this;a.callParent(arguments);a.doc=Ext.getDoc();a.initTrigger();a.triggerEl.unselectable()},getTriggerWidth:function(){var b=this,a=0;if(b.triggerWrap&&!b.hideTrigger&&!b.readOnly){a=b.triggerEl.getCount()*b.triggerWidth}return a},setHideTrigger:function(a){if(a!=this.hideTrigger){this.hideTrigger=a;this.updateLayout()}},setEditable:function(a){if(a!=this.editable){this.editable=a;this.updateLayout()}},setReadOnly:function(a){if(a!=this.readOnly){this.readOnly=a;this.updateLayout()}},initTrigger:function(){var h=this,i=h.triggerWrap,k=h.triggerEl,a=h.disableCheck,d,c,b,g,j;if(h.repeatTriggerClick){h.triggerRepeater=new Ext.util.ClickRepeater(i,{preventDefault:true,handler:h.onTriggerWrapClick,listeners:{mouseup:h.onTriggerWrapMouseup,scope:h},scope:h})}else{h.mon(i,{click:h.onTriggerWrapClick,mouseup:h.onTriggerWrapMouseup,scope:h})}k.setVisibilityMode(Ext.Element.DISPLAY);k.addClsOnOver(h.triggerBaseCls+"-over",a,h);d=k.elements;c=d.length;for(g=0;g<c;g++){b=d[g];j=g+1;b.addClsOnOver(h["trigger"+(j)+"Cls"]+"-over",a,h);b.addClsOnClick(h["trigger"+(j)+"Cls"]+"-click",a,h)}k.addClsOnClick(h.triggerBaseCls+"-click",a,h)},onDestroy:function(){var a=this;Ext.destroyMembers(a,"triggerRepeater","triggerWrap","triggerEl");delete a.doc;a.callParent()},onFocus:function(){var a=this;a.callParent(arguments);if(!a.mimicing){a.bodyEl.addCls(a.wrapFocusCls);a.mimicing=true;a.mon(a.doc,"mousedown",a.mimicBlur,a,{delay:10});if(a.monitorTab){a.on("specialkey",a.checkTab,a)}}},checkTab:function(a,b){if(!this.ignoreMonitorTab&&b.getKey()==b.TAB){this.triggerBlur()}},getTriggerStateFlags:function(){var a=this,b=0;if(a.readOnly){b+=1}if(a.editable){b+=2}if(a.hideTrigger){b+=4}return b},onBlur:Ext.emptyFn,mimicBlur:function(a){if(!this.isDestroyed&&!this.bodyEl.contains(a.target)&&this.validateBlur(a)){this.triggerBlur(a)}},triggerBlur:function(b){var a=this;a.mimicing=false;a.mun(a.doc,"mousedown",a.mimicBlur,a);if(a.monitorTab&&a.inputEl){a.un("specialkey",a.checkTab,a)}Ext.form.field.Trigger.superclass.onBlur.call(a,b);if(a.bodyEl){a.bodyEl.removeCls(a.wrapFocusCls)}},validateBlur:function(a){return true},onTriggerWrapClick:function(){var d=this,e,b,a,c;c=arguments[d.triggerRepeater?1:0];if(c&&!d.readOnly&&!d.disabled){e=c.getTarget("."+d.triggerBaseCls,null);b=e&&e.className.match(d.triggerIndexRe);if(b){a=d["onTrigger"+(parseInt(b[1],10)+1)+"Click"]||d.onTriggerClick;if(a){a.call(d,c)}}}},onTriggerWrapMouseup:Ext.emptyFn,onTriggerClick:Ext.emptyFn});Ext.define("Ext.form.field.Picker",{extend:"Ext.form.field.Trigger",alias:"widget.pickerfield",alternateClassName:"Ext.form.Picker",requires:["Ext.util.KeyNav"],matchFieldWidth:true,pickerAlign:"tl-bl?",openCls:Ext.baseCSSPrefix+"pickerfield-open",editable:true,initComponent:function(){this.callParent();this.addEvents("expand","collapse","select")},initEvents:function(){var a=this;a.callParent();a.keyNav=new Ext.util.KeyNav(a.inputEl,{down:a.onDownArrow,esc:{handler:a.onEsc,scope:a,defaultEventAction:false},scope:a,forceKeyDown:true});if(!a.editable){a.mon(a.inputEl,"click",a.onTriggerClick,a)}if(Ext.isGecko){a.inputEl.dom.setAttribute("autocomplete","off")}},onEsc:function(b){var a=this;if(a.isExpanded){a.collapse();b.stopEvent()}else{if(a.up("window")){a.blur()}else{if((!Ext.FocusManager||!Ext.FocusManager.enabled)){b.stopEvent()}}}},onDownArrow:function(a){if(!this.isExpanded){this.onTriggerClick()}},expand:function(){var c=this,a,b,d;if(c.rendered&&!c.isExpanded&&!c.isDestroyed){a=c.bodyEl;b=c.getPicker();d=c.collapseIf;b.show();c.isExpanded=true;c.alignPicker();a.addCls(c.openCls);c.mon(Ext.getDoc(),{mousewheel:d,mousedown:d,scope:c});Ext.EventManager.onWindowResize(c.alignPicker,c);c.fireEvent("expand",c);c.onExpand()}},onExpand:Ext.emptyFn,alignPicker:function(){var b=this,a=b.getPicker();if(b.isExpanded){if(b.matchFieldWidth){a.setWidth(b.bodyEl.getWidth())}if(a.isFloating()){b.doAlign()}}},doAlign:function(){var d=this,c=d.picker,a="-above",b;d.picker.alignTo(d.inputEl,d.pickerAlign,d.pickerOffset);b=c.el.getY()<d.inputEl.getY();d.bodyEl[b?"addCls":"removeCls"](d.openCls+a);c[b?"addCls":"removeCls"](c.baseCls+a)},collapse:function(){if(this.isExpanded&&!this.isDestroyed){var d=this,c=d.openCls,b=d.picker,e=Ext.getDoc(),g=d.collapseIf,a="-above";b.hide();d.isExpanded=false;d.bodyEl.removeCls([c,c+a]);b.el.removeCls(b.baseCls+a);e.un("mousewheel",g,d);e.un("mousedown",g,d);Ext.EventManager.removeResizeListener(d.alignPicker,d);d.fireEvent("collapse",d);d.onCollapse()}},onCollapse:Ext.emptyFn,collapseIf:function(b){var a=this;if(!a.isDestroyed&&!b.within(a.bodyEl,false,true)&&!b.within(a.picker.el,false,true)&&!a.isEventWithinPickerLoadMask(b)){a.collapse()}},getPicker:function(){var a=this;return a.picker||(a.picker=a.createPicker())},createPicker:Ext.emptyFn,onTriggerClick:function(){var a=this;if(!a.readOnly&&!a.disabled){if(a.isExpanded){a.collapse()}else{a.expand()}a.inputEl.focus()}},mimicBlur:function(c){var b=this,a=b.picker;if(!a||!c.within(a.el,false,true)&&!b.isEventWithinPickerLoadMask(c)){b.callParent(arguments)}},onDestroy:function(){var b=this,a=b.picker;Ext.EventManager.removeResizeListener(b.alignPicker,b);Ext.destroy(b.keyNav);if(a){delete a.pickerField;a.destroy()}b.callParent()},isEventWithinPickerLoadMask:function(b){var a=this.picker.loadMask;return a?b.within(a.maskEl,false,true)||b.within(a.el,false,true):false}});Ext.define("Ext.layout.component.BoundList",{extend:"Ext.layout.component.Auto",alias:"layout.boundlist",type:"component",beginLayout:function(d){var c=this,a=c.owner,b=a.pagingToolbar;c.callParent(arguments);if(a.floating){d.savedXY=a.el.getXY();a.el.setXY([-9999,-9999])}if(b){d.toolbarContext=d.context.getCmp(b)}d.listContext=d.getEl("listEl")},beginLayoutCycle:function(b){var a=this.owner;this.callParent(arguments);if(b.heightModel.auto){a.el.setHeight("auto");a.listEl.setHeight("auto")}},getLayoutItems:function(){var a=this.owner.pagingToolbar;return a?[a]:[]},isValidParent:function(){return true},finishedLayout:function(a){var b=a.savedXY;this.callParent(arguments);if(b){this.owner.el.setXY(b)}},measureContentWidth:function(a){return this.owner.listEl.getWidth()},measureContentHeight:function(a){return this.owner.listEl.getHeight()},publishInnerHeight:function(c,a){var b=c.toolbarContext,d=0;if(b){d=b.getProp("height")}if(d===undefined){this.done=false}else{c.listContext.setHeight(a-c.getFrameInfo().height-d)}},calculateOwnerHeightFromContentHeight:function(c){var a=this.callParent(arguments),b=c.toolbarContext;if(b){a+=b.getProp("height")}return a}});Ext.define("Ext.selection.Model",{extend:"Ext.util.Observable",alternateClassName:"Ext.AbstractSelectionModel",requires:["Ext.data.StoreManager"],mixins:{bindable:"Ext.util.Bindable"},allowDeselect:false,selected:null,pruneRemoved:true,constructor:function(a){var b=this;a=a||{};Ext.apply(b,a);b.addEvents("selectionchange","focuschange");b.modes={SINGLE:true,SIMPLE:true,MULTI:true};b.setSelectionMode(a.mode||b.mode);b.selected=new Ext.util.MixedCollection();b.callParent(arguments)},bindStore:function(a,b){var c=this;c.mixins.bindable.bindStore.apply(c,arguments);if(c.store&&!b){c.refresh()}},getStoreListeners:function(){var a=this;return{add:a.onStoreAdd,clear:a.onStoreClear,remove:a.onStoreRemove,update:a.onStoreUpdate}},selectAll:function(b){var e=this,d=e.store.getRange(),c=0,a=d.length,g=e.getSelection().length;e.bulkChange=true;for(;c<a;c++){e.doSelect(d[c],true,b)}delete e.bulkChange;e.maybeFireSelectionChange(e.getSelection().length!==g)},deselectAll:function(b){var e=this,d=e.getSelection(),c=0,a=d.length,g=e.getSelection().length;e.bulkChange=true;for(;c<a;c++){e.doDeselect(d[c],b)}delete e.bulkChange;e.maybeFireSelectionChange(e.getSelection().length!==g)},selectWithEvent:function(a,d,c){var b=this;switch(b.selectionMode){case"MULTI":if(d.ctrlKey&&b.isSelected(a)){b.doDeselect(a,false)}else{if(d.shiftKey&&b.lastFocused){b.selectRange(b.lastFocused,a,d.ctrlKey)}else{if(d.ctrlKey){b.doSelect(a,true,false)}else{if(b.isSelected(a)&&!d.shiftKey&&!d.ctrlKey&&b.selected.getCount()>1){b.doSelect(a,c,false)}else{b.doSelect(a,false)}}}}break;case"SIMPLE":if(b.isSelected(a)){b.doDeselect(a)}else{b.doSelect(a,true)}break;case"SINGLE":if(b.allowDeselect&&b.isSelected(a)){b.doDeselect(a)}else{b.doSelect(a,false)}break}},selectRange:function(l,e,m,c){var j=this,k=j.store,d=0,h,g,a,b=[];if(j.isLocked()){return}if(!m){j.deselectAll(true)}if(!Ext.isNumber(l)){l=k.indexOf(l)}if(!Ext.isNumber(e)){e=k.indexOf(e)}if(l>e){g=e;e=l;l=g}for(h=l;h<=e;h++){if(j.isSelected(k.getAt(h))){d++}}if(!c){a=-1}else{a=(c=="up")?l:e}for(h=l;h<=e;h++){if(d==(e-l+1)){if(h!=a){j.doDeselect(h,true)}}else{b.push(k.getAt(h))}}j.doMultiSelect(b,true)},select:function(b,c,a){if(Ext.isDefined(b)){this.doSelect(b,c,a)}},deselect:function(b,a){this.doDeselect(b,a)},doSelect:function(c,e,b){var d=this,a;if(d.locked||!d.store){return}if(typeof c==="number"){c=[d.store.getAt(c)]}if(d.selectionMode=="SINGLE"&&c){a=c.length?c[0]:c;d.doSingleSelect(a,b)}else{d.doMultiSelect(c,e,b)}},doMultiSelect:function(a,l,k){var h=this,b=h.selected,j=false,d=0,g,e;if(h.locked){return}a=!Ext.isArray(a)?[a]:a;g=a.length;if(!l&&b.getCount()>0){if(h.doDeselect(h.getSelection(),k)===false){return}}function c(){b.add(e);j=true}for(;d<g;d++){e=a[d];if(l&&h.isSelected(e)){continue}h.lastSelected=e;h.onSelectChange(e,true,k,c)}if(!h.preventFocus){h.setLastFocused(e,k)}h.maybeFireSelectionChange(j&&!k)},doDeselect:function(a,k){var j=this,b=j.selected,d=0,h,e,l=0,g=0;if(j.locked||!j.store){return false}if(typeof a==="number"){a=[j.store.getAt(a)]}else{if(!Ext.isArray(a)){a=[a]}}function c(){++g;b.remove(e)}h=a.length;for(;d<h;d++){e=a[d];if(j.isSelected(e)){if(j.lastSelected==e){j.lastSelected=b.last()}++l;j.onSelectChange(e,false,k,c)}}j.maybeFireSelectionChange(g>0&&!k);return g===l},doSingleSelect:function(a,b){var d=this,g=false,c=d.selected;if(d.locked){return}if(d.isSelected(a)){return}function e(){d.bulkChange=true;if(c.getCount()>0&&d.doDeselect(d.lastSelected,b)===false){delete d.bulkChange;return false}delete d.bulkChange;c.add(a);d.lastSelected=a;g=true}d.onSelectChange(a,true,b,e);if(g){if(!b){d.setLastFocused(a)}d.maybeFireSelectionChange(!b)}},setLastFocused:function(c,b){var d=this,a=d.lastFocused;d.lastFocused=c;if(c!==a){d.onLastFocusChanged(a,c,b)}},isFocused:function(a){return a===this.getLastFocused()},maybeFireSelectionChange:function(a){var b=this;if(a&&!b.bulkChange){b.fireEvent("selectionchange",b,b.getSelection())}},getLastSelected:function(){return this.lastSelected},getLastFocused:function(){return this.lastFocused},getSelection:function(){return this.selected.getRange()},getSelectionMode:function(){return this.selectionMode},setSelectionMode:function(a){a=a?a.toUpperCase():"SINGLE";this.selectionMode=this.modes[a]?a:"SINGLE"},isLocked:function(){return this.locked},setLocked:function(a){this.locked=!!a},isSelected:function(a){a=Ext.isNumber(a)?this.store.getAt(a):a;return this.selected.indexOf(a)!==-1},hasSelection:function(){return this.selected.getCount()>0},refresh:function(){var e=this,j=e.store,c=[],a=e.getSelection(),d=a.length,h,g,b=0,k=e.getLastFocused();if(!j){return}for(;b<d;b++){h=a[b];if(!e.pruneRemoved||j.indexOf(h)!==-1){c.push(h)}}if(e.selected.getCount()!=c.length){g=true}e.clearSelections();if(j.indexOf(k)!==-1){e.setLastFocused(k,true)}if(c.length){e.doSelect(c,false,true)}e.maybeFireSelectionChange(g)},clearSelections:function(){this.selected.clear();this.lastSelected=null;this.setLastFocused(null)},onStoreAdd:Ext.emptyFn,onStoreClear:function(){if(this.selected.getCount>0){this.clearSelections();this.maybeFireSelectionChange(true)}},onStoreRemove:function(b,a,c){var e=this,d=e.selected;if(e.locked||!e.pruneRemoved){return}if(d.remove(a)){if(e.lastSelected==a){e.lastSelected=null}if(e.getLastFocused()==a){e.setLastFocused(null)}e.maybeFireSelectionChange(true)}},getCount:function(){return this.selected.getCount()},destroy:Ext.emptyFn,onStoreUpdate:Ext.emptyFn,onStoreLoad:Ext.emptyFn,onSelectChange:Ext.emptyFn,onLastFocusChanged:function(b,a){this.fireEvent("focuschange",this,b,a)},onEditorKey:Ext.emptyFn,bindComponent:Ext.emptyFn,beforeViewRender:Ext.emptyFn});Ext.define("Ext.selection.DataViewModel",{extend:"Ext.selection.Model",requires:["Ext.util.KeyNav"],deselectOnContainerClick:true,enableKeyNav:true,constructor:function(a){this.addEvents("beforedeselect","beforeselect","deselect","select");this.callParent(arguments)},bindComponent:function(a){var b=this,c={refresh:b.refresh,scope:b};b.view=a;b.bindStore(a.getStore());c[a.triggerEvent]=b.onItemClick;c[a.triggerCtEvent]=b.onContainerClick;a.on(c);if(b.enableKeyNav){b.initKeyNav(a)}},onItemClick:function(b,a,d,c,g){this.selectWithEvent(a,g)},onContainerClick:function(){if(this.deselectOnContainerClick){this.deselectAll()}},initKeyNav:function(a){var b=this;if(!a.rendered){a.on({render:Ext.Function.bind(b.initKeyNav,b,[a]),single:true});return}a.el.set({tabIndex:-1});b.keyNav=new Ext.util.KeyNav({target:a.el,ignoreInputFields:true,down:Ext.pass(b.onNavKey,[1],b),right:Ext.pass(b.onNavKey,[1],b),left:Ext.pass(b.onNavKey,[-1],b),up:Ext.pass(b.onNavKey,[-1],b),scope:b})},onNavKey:function(g){g=g||1;var e=this,b=e.view,d=e.getSelection()[0],c=e.view.store.getCount(),a;if(d){a=b.indexOf(b.getNode(d))+g}else{a=0}if(a<0){a=c-1}else{if(a>=c){a=0}}e.select(a)},onSelectChange:function(b,e,d,h){var g=this,a=g.view,c=e?"select":"deselect";if((d||g.fireEvent("before"+c,g,b))!==false&&h()!==false){if(a){if(e){a.onItemSelect(b)}else{a.onItemDeselect(b)}}if(!d){g.fireEvent(c,g,b)}}},destroy:function(){Ext.destroy(this.keyNav);this.callParent()}});Ext.define("Ext.view.AbstractView",{extend:"Ext.Component",requires:["Ext.LoadMask","Ext.data.StoreManager","Ext.CompositeElementLite","Ext.DomQuery","Ext.selection.DataViewModel"],mixins:{bindable:"Ext.util.Bindable"},inheritableStatics:{getRecord:function(a){return this.getBoundView(a).getRecord(a)},getBoundView:function(a){return Ext.getCmp(a.boundView)}},deferInitialRefresh:true,itemCls:Ext.baseCSSPrefix+"dataview-item",loadingText:"Loading...",loadMask:true,loadingUseMsg:true,selectedItemCls:Ext.baseCSSPrefix+"item-selected",emptyText:"",deferEmptyText:true,trackOver:false,blockRefresh:false,preserveScrollOnRefresh:false,last:false,triggerEvent:"itemclick",triggerCtEvent:"containerclick",addCmpEvents:function(){},initComponent:function(){var c=this,a=Ext.isDefined,d=c.itemTpl,b={};if(d){if(Ext.isArray(d)){d=d.join("")}else{if(Ext.isObject(d)){b=Ext.apply(b,d.initialConfig);d=d.html}}if(!c.itemSelector){c.itemSelector="."+c.itemCls}d=Ext.String.format('<tpl for="."><div class="{0}">{1}</div></tpl>',c.itemCls,d);c.tpl=new Ext.XTemplate(d,b)}c.callParent();if(Ext.isString(c.tpl)||Ext.isArray(c.tpl)){c.tpl=new Ext.XTemplate(c.tpl)}c.addEvents("beforerefresh","refresh","viewready","itemupdate","itemadd","itemremove");c.addCmpEvents();c.store=Ext.data.StoreManager.lookup(c.store||"ext-empty-store");c.bindStore(c.store,true);c.all=new Ext.CompositeElementLite();c.scrollState={top:0,left:0};c.on({scroll:c.onViewScroll,element:"el",scope:c})},onRender:function(){var c=this,b=c.loadMask,a={msg:c.loadingText,msgCls:c.loadingCls,useMsg:c.loadingUseMsg,store:c.getMaskStore()};c.callParent(arguments);if(b){if(Ext.isObject(b)){a=Ext.apply(a,b)}c.loadMask=new Ext.LoadMask(c,a);c.loadMask.on({scope:c,beforeshow:c.onMaskBeforeShow,hide:c.onMaskHide})}},finishRender:function(){var a=this;a.callParent(arguments);if(!a.up("[collapsed],[hidden]")){a.doFirstRefresh(a.store)}},onBoxReady:function(){var a=this;a.callParent(arguments);if(!a.firstRefreshDone){a.doFirstRefresh(a.store)}},getMaskStore:function(){return this.store},onMaskBeforeShow:function(){var b=this,a=b.loadingHeight;b.getSelectionModel().deselectAll();b.all.clear();if(a&&a>b.getHeight()){b.hasLoadingHeight=true;b.oldMinHeight=b.minHeight;b.minHeight=a;b.updateLayout()}},onMaskHide:function(){var a=this;if(!a.destroying&&a.hasLoadingHeight){a.minHeight=a.oldMinHeight;a.updateLayout();delete a.hasLoadingHeight}},beforeRender:function(){this.callParent(arguments);this.getSelectionModel().beforeViewRender(this)},afterRender:function(){this.callParent(arguments);this.getSelectionModel().bindComponent(this)},getSelectionModel:function(){var a=this,b="SINGLE";if(!a.selModel){a.selModel={}}if(a.simpleSelect){b="SIMPLE"}else{if(a.multiSelect){b="MULTI"}}Ext.applyIf(a.selModel,{allowDeselect:a.allowDeselect,mode:b});if(!a.selModel.events){a.selModel=new Ext.selection.DataViewModel(a.selModel)}if(!a.selModel.hasRelaySetup){a.relayEvents(a.selModel,["selectionchange","beforeselect","beforedeselect","select","deselect","focuschange"]);a.selModel.hasRelaySetup=true}if(a.disableSelection){a.selModel.locked=true}return a.selModel},refresh:function(){var c=this,h,b,e,d,g,a;if(!c.rendered||c.isDestroyed){return}if(!c.hasListeners.beforerefresh||c.fireEvent("beforerefresh",c)!==false){h=c.getTargetEl();a=c.store.getRange();g=h.dom;if(!c.preserveScrollOnRefresh){b=g.parentNode;e=g.style.display;g.style.display="none";d=g.nextSibling;b.removeChild(g)}if(c.refreshCounter){c.clearViewEl()}else{c.fixedNodes=h.dom.childNodes.length;c.refreshCounter=1}c.tpl.append(h,c.collectData(a,0));if(a.length<1){if(!c.deferEmptyText||c.hasSkippedEmptyText){Ext.core.DomHelper.insertHtml("beforeEnd",h.dom,c.emptyText)}c.all.clear()}else{c.all.fill(Ext.query(c.getItemSelector(),h.dom));c.updateIndexes(0)}c.selModel.refresh();c.hasSkippedEmptyText=true;if(!c.preserveScrollOnRefresh){b.insertBefore(g,d);g.style.display=e}this.refreshSize();c.fireEvent("refresh",c);if(!c.viewReady){c.viewReady=true;c.fireEvent("viewready",c)}}},refreshSize:function(){var a=this.getSizeModel();if(a.height.shrinkWrap||a.width.shrinkWrap){this.updateLayout()}},clearViewEl:function(){var b=this,a=b.getTargetEl();if(b.fixedNodes){while(a.dom.childNodes[b.fixedNodes]){a.dom.removeChild(a.dom.childNodes[b.fixedNodes])}}else{a.update("")}b.refreshCounter++},onViewScroll:Ext.emptyFn,saveScrollState:function(){if(this.rendered){var b=this.el.dom,a=this.scrollState;a.left=b.scrollLeft;a.top=b.scrollTop}},restoreScrollState:function(){if(this.rendered){var b=this.el.dom,a=this.scrollState;b.scrollLeft=a.left;b.scrollTop=a.top}},prepareData:function(e,d,c){var b,a;if(c){b=c.getAssociatedData();for(a in b){if(b.hasOwnProperty(a)){e[a]=b[a]}}}return e},collectData:function(c,g){var e=[],d=0,a=c.length,b;for(;d<a;d++){b=c[d];e[d]=this.prepareData(b.data,g+d,b)}return e},bufferRender:function(a,b){var c=this,d=c.renderBuffer||(c.renderBuffer=document.createElement("div"));c.tpl.overwrite(d,c.collectData(a,b));return Ext.query(c.getItemSelector(),d)},onUpdate:function(e,a){var d=this,b,c;if(d.viewReady){b=d.store.indexOf(a);if(b>-1){c=d.bufferRender([a],b)[0];if(d.getNode(a)){d.all.replaceElement(b,c,true);d.updateIndexes(b,b);d.selModel.refresh();if(d.hasListeners.itemupdate){d.fireEvent("itemupdate",a,b,c)}return c}}}},onAdd:function(e,b,c){var d=this,a;if(d.rendered){if(d.all.getCount()===0){d.refresh();return}a=d.bufferRender(b,c);d.doAdd(a,b,c);d.selModel.refresh();d.updateIndexes(c);d.refreshSize();if(d.hasListeners.itemadd){d.fireEvent("itemadd",b,c,a)}}},doAdd:function(b,a,c){var d=this.all,e=d.getCount();if(e===0){this.clearViewEl();this.getTargetEl().appendChild(b)}else{if(c<e){if(c===0){d.item(c).insertSibling(b,"before",true)}else{d.item(c-1).insertSibling(b,"after",true)}}else{d.last().insertSibling(b,"after",true)}}Ext.Array.insert(d.elements,c,b)},onRemove:function(d,a,b){var c=this;if(c.all.getCount()){if(c.store.getCount()===0){c.refresh()}else{c.doRemove(a,b);if(c.selModel.refreshOnRemove){c.selModel.refresh()}c.updateIndexes(b)}this.refreshSize();if(c.hasListeners.itemremove){c.fireEvent("itemremove",a,b)}}},doRemove:function(a,b){this.all.removeElement(b,true)},refreshNode:function(a){this.onUpdate(this.store,this.store.getAt(a))},updateIndexes:function(e,d){var c=this.all.elements,a=this.store.getRange(),b;e=e||0;d=d||((d===0)?0:(c.length-1));for(b=e;b<=d;b++){c[b].viewIndex=b;c[b].viewRecordId=a[b].internalId;if(!c[b].boundView){c[b].boundView=this.id}}},getStore:function(){return this.store},bindStore:function(a,b){var c=this;c.mixins.bindable.bindStore.apply(c,arguments);if(!b){c.getSelectionModel().bindStore(c.store)}if(c.componentLayoutCounter){c.doFirstRefresh(a)}},doFirstRefresh:function(a){var b=this;b.firstRefreshDone=true;if(a&&!a.loading){if(b.deferInitialRefresh){b.applyFirstRefresh()}else{b.refresh()}}},applyFirstRefresh:function(){var a=this;if(a.isDestroyed){return}if(a.up("[isCollapsingOrExpanding]")){Ext.Function.defer(a.applyFirstRefresh,100,a)}else{Ext.Function.defer(function(){if(!a.isDestroyed){a.refresh()}},1)}},onUnbindStore:function(a){this.setMaskBind(null)},onBindStore:function(a){this.setMaskBind(a)},setMaskBind:function(b){var a=this.loadMask;if(a&&a.bindStore){a.bindStore(b)}},getStoreListeners:function(){var a=this;return{refresh:a.onDataRefresh,add:a.onAdd,remove:a.onRemove,update:a.onUpdate,clear:a.refresh}},onDataRefresh:function(){var a=this,b=!a.firstRefreshDone&&(!a.rendered||a.up("[collapsed],[isCollapsingOrExpanding],[hidden]"));if(b){a.deferInitialRefresh=false}else{if(a.blockRefresh!==true){a.firstRefreshDone=true;a.refresh.apply(a,arguments)}}},findItemByChild:function(a){return Ext.fly(a).findParent(this.getItemSelector(),this.getTargetEl())},findTargetByEvent:function(a){return a.getTarget(this.getItemSelector(),this.getTargetEl())},getSelectedNodes:function(){var b=[],a=this.selModel.getSelection(),d=a.length,c=0;for(;c<d;c++){b.push(this.getNode(a[c]))}return b},getRecords:function(c){var b=[],d=0,a=c.length,e=this.store.data;for(;d<a;d++){b[b.length]=e.getByKey(c[d].viewRecordId)}return b},getRecord:function(a){return this.store.data.getByKey(Ext.getDom(a).viewRecordId)},isSelected:function(b){var a=this.getRecord(b);return this.selModel.isSelected(a)},select:function(b,c,a){this.selModel.select(b,c,a)},deselect:function(b,a){this.selModel.deselect(b,a)},getNode:function(a){if((!a&&a!==0)||!this.rendered){return null}if(Ext.isString(a)){return document.getElementById(a)}if(Ext.isNumber(a)){return this.all.elements[a]}if(a.isModel){return this.getNodeByRecord(a)}return a},getNodeByRecord:function(a){var c=this.all.elements,d=c.length,b=0;for(;b<d;b++){if(c[b].viewRecordId===a.internalId){return c[b]}}return null},getNodes:function(c,a){var b=this.all.elements;if(a===undefined){a=b.length}else{a++}return this.all.elements.slice(c||0,a)},indexOf:function(a){a=this.getNode(a);if(!a&&a!==0){return -1}if(Ext.isNumber(a.viewIndex)){return a.viewIndex}return this.all.indexOf(a)},onDestroy:function(){var a=this;a.all.clear();a.callParent();a.bindStore(null);a.selModel.destroy()},onItemSelect:function(a){var b=this.getNode(a);if(b){Ext.fly(b).addCls(this.selectedItemCls)}},onItemDeselect:function(a){var b=this.getNode(a);if(b){Ext.fly(b).removeCls(this.selectedItemCls)}},getItemSelector:function(){return this.itemSelector}},function(){Ext.deprecate("extjs","4.0",function(){Ext.view.AbstractView.override({getSelectionCount:function(){if(Ext.global.console){Ext.global.console.warn("DataView: getSelectionCount will be removed, please interact with the Ext.selection.DataViewModel")}return this.selModel.getSelection().length},getSelectedRecords:function(){if(Ext.global.console){Ext.global.console.warn("DataView: getSelectedRecords will be removed, please interact with the Ext.selection.DataViewModel")}return this.selModel.getSelection()},select:function(a,b,d){if(Ext.global.console){Ext.global.console.warn("DataView: select will be removed, please access select through a DataView's SelectionModel, ie: view.getSelectionModel().select()")}var c=this.getSelectionModel();return c.select.apply(c,arguments)},clearSelections:function(){if(Ext.global.console){Ext.global.console.warn("DataView: clearSelections will be removed, please access deselectAll through DataView's SelectionModel, ie: view.getSelectionModel().deselectAll()")}var a=this.getSelectionModel();return a.deselectAll()}})})});Ext.define("Ext.view.View",{extend:"Ext.view.AbstractView",alternateClassName:"Ext.DataView",alias:"widget.dataview",deferHighlight:(Ext.isIE6||Ext.isIE7)?100:0,inputTagRe:/^textarea$|^input$/i,inheritableStatics:{EventMap:{mousedown:"MouseDown",mouseup:"MouseUp",click:"Click",dblclick:"DblClick",contextmenu:"ContextMenu",mouseover:"MouseOver",mouseout:"MouseOut",mouseenter:"MouseEnter",mouseleave:"MouseLeave",keydown:"KeyDown",focus:"Focus"}},initComponent:function(){var a=this;a.callParent();if(a.deferHighlight){a.setHighlightedItem=Ext.Function.createBuffered(a.setHighlightedItem,a.deferHighlight,a)}},addCmpEvents:function(){this.addEvents("beforeitemmousedown","beforeitemmouseup","beforeitemmouseenter","beforeitemmouseleave","beforeitemclick","beforeitemdblclick","beforeitemcontextmenu","beforeitemkeydown","itemmousedown","itemmouseup","itemmouseenter","itemmouseleave","itemclick","itemdblclick","itemcontextmenu","itemkeydown","beforecontainermousedown","beforecontainermouseup","beforecontainermouseover","beforecontainermouseout","beforecontainerclick","beforecontainerdblclick","beforecontainercontextmenu","beforecontainerkeydown","containermouseup","containermouseover","containermouseout","containerclick","containerdblclick","containercontextmenu","containerkeydown","selectionchange","beforeselect","beforedeselect","select","deselect","focuschange","highlightitem","unhighlightitem")},getFocusEl:function(){return this.getTargetEl()},afterRender:function(){var a=this;a.callParent();a.mon(a.getTargetEl(),{scope:a,freezeEvent:true,click:a.handleEvent,mousedown:a.handleEvent,mouseup:a.handleEvent,dblclick:a.handleEvent,contextmenu:a.handleEvent,mouseover:a.handleEvent,mouseout:a.handleEvent,keydown:a.handleEvent})},handleEvent:function(c){var b=this,a=c.type=="keydown"&&c.getKey();if(b.processUIEvent(c)!==false){b.processSpecialEvent(c)}if(a===c.SPACE){if(!b.inputTagRe.test(c.getTarget().tagName)){c.stopEvent()}}},processItemEvent:Ext.emptyFn,processContainerEvent:Ext.emptyFn,processSpecialEvent:Ext.emptyFn,stillOverItem:function(b,a){var c;if(a&&typeof(a.offsetParent)==="object"){c=(b.type=="mouseout")?b.getRelatedTarget():b.getTarget();return Ext.fly(a).contains(c)}return false},processUIEvent:function(h){var i=this,k=h.getTarget(i.getItemSelector(),i.getTargetEl()),a=this.statics().EventMap,g,c,j=h.type,d=i.mouseOverItem,b;if(!k){if(j=="mouseover"&&i.stillOverItem(h,d)){k=d}if(j=="keydown"){c=i.getSelectionModel().getLastSelected();if(c){k=i.getNode(c)}}}if(k){g=i.indexOf(k);if(!c){c=i.getRecord(k)}if(!c||i.processItemEvent(c,k,g,h)===false){return false}b=i.isNewItemEvent(k,h);if(b===false){return false}if((i["onBeforeItem"+a[b]](c,k,g,h)===false)||(i.fireEvent("beforeitem"+b,i,c,k,g,h)===false)||(i["onItem"+a[b]](c,k,g,h)===false)){return false}i.fireEvent("item"+b,i,c,k,g,h)}else{if((i.processContainerEvent(h)===false)||(i["onBeforeContainer"+a[j]](h)===false)||(i.fireEvent("beforecontainer"+j,i,h)===false)||(i["onContainer"+a[j]](h)===false)){return false}i.fireEvent("container"+j,i,h)}return true},isNewItemEvent:function(d,g){var c=this,a=c.mouseOverItem,b=g.type;switch(b){case"mouseover":if(d===a){return false}c.mouseOverItem=d;return"mouseenter";case"mouseout":if(c.stillOverItem(g,a)){return false}c.mouseOverItem=null;return"mouseleave"}return b},onItemMouseEnter:function(a,c,b,d){if(this.trackOver){this.highlightItem(c)}},onItemMouseLeave:function(a,c,b,d){if(this.trackOver){this.clearHighlight()}},onItemMouseDown:Ext.emptyFn,onItemMouseUp:Ext.emptyFn,onItemFocus:Ext.emptyFn,onItemClick:Ext.emptyFn,onItemDblClick:Ext.emptyFn,onItemContextMenu:Ext.emptyFn,onItemKeyDown:Ext.emptyFn,onBeforeItemMouseDown:Ext.emptyFn,onBeforeItemMouseUp:Ext.emptyFn,onBeforeItemFocus:Ext.emptyFn,onBeforeItemMouseEnter:Ext.emptyFn,onBeforeItemMouseLeave:Ext.emptyFn,onBeforeItemClick:Ext.emptyFn,onBeforeItemDblClick:Ext.emptyFn,onBeforeItemContextMenu:Ext.emptyFn,onBeforeItemKeyDown:Ext.emptyFn,onContainerMouseDown:Ext.emptyFn,onContainerMouseUp:Ext.emptyFn,onContainerMouseOver:Ext.emptyFn,onContainerMouseOut:Ext.emptyFn,onContainerClick:Ext.emptyFn,onContainerDblClick:Ext.emptyFn,onContainerContextMenu:Ext.emptyFn,onContainerKeyDown:Ext.emptyFn,onBeforeContainerMouseDown:Ext.emptyFn,onBeforeContainerMouseUp:Ext.emptyFn,onBeforeContainerMouseOver:Ext.emptyFn,onBeforeContainerMouseOut:Ext.emptyFn,onBeforeContainerClick:Ext.emptyFn,onBeforeContainerDblClick:Ext.emptyFn,onBeforeContainerContextMenu:Ext.emptyFn,onBeforeContainerKeyDown:Ext.emptyFn,setHighlightedItem:function(c){var b=this,a=b.highlightedItem;if(a!=c){if(a){Ext.fly(a).removeCls(b.overItemCls);b.fireEvent("unhighlightitem",b,a)}b.highlightedItem=c;if(c){Ext.fly(c).addCls(b.overItemCls);b.fireEvent("highlightitem",b,c)}}},highlightItem:function(a){this.setHighlightedItem(a)},clearHighlight:function(){this.setHighlightedItem(undefined)},onUpdate:function(b,a){var g=this,e,c,d;if(g.viewReady){e=g.getNode(a);c=g.callParent(arguments);d=g.highlightedItem;if(d&&d===e){delete g.highlightedItem;if(c){g.highlightItem(c)}}}},refresh:function(){this.clearHighlight();this.callParent(arguments)}});Ext.define("Ext.toolbar.TextItem",{extend:"Ext.toolbar.Item",requires:["Ext.XTemplate"],alias:"widget.tbtext",alternateClassName:"Ext.Toolbar.TextItem",text:"",renderTpl:"{text}",baseCls:Ext.baseCSSPrefix+"toolbar-text",beforeRender:function(){var a=this;a.callParent();Ext.apply(a.renderData,{text:a.text})},setText:function(b){var a=this;if(a.rendered){a.el.update(b);a.updateLayout()}else{this.text=b}}});Ext.define("Ext.form.field.Spinner",{extend:"Ext.form.field.Trigger",alias:"widget.spinnerfield",alternateClassName:"Ext.form.Spinner",requires:["Ext.util.KeyNav"],trigger1Cls:Ext.baseCSSPrefix+"form-spinner-up",trigger2Cls:Ext.baseCSSPrefix+"form-spinner-down",spinUpEnabled:true,spinDownEnabled:true,keyNavEnabled:true,mouseWheelEnabled:true,repeatTriggerClick:true,onSpinUp:Ext.emptyFn,onSpinDown:Ext.emptyFn,triggerTpl:'<td style="{triggerStyle}"><div class="'+Ext.baseCSSPrefix+"trigger-index-0 "+Ext.baseCSSPrefix+"form-trigger "+Ext.baseCSSPrefix+'form-spinner-up" role="button"></div><div class="'+Ext.baseCSSPrefix+"trigger-index-1 "+Ext.baseCSSPrefix+"form-trigger "+Ext.baseCSSPrefix+'form-spinner-down" role="button"></div></td></tr>',initComponent:function(){this.callParent();this.addEvents("spin","spinup","spindown")},onRender:function(){var b=this,a;b.callParent(arguments);a=b.triggerEl;b.spinUpEl=a.item(0);b.spinDownEl=a.item(1);b.triggerCell=b.spinUpEl.parent();b.setSpinUpEnabled(b.spinUpEnabled);b.setSpinDownEnabled(b.spinDownEnabled);if(b.keyNavEnabled){b.spinnerKeyNav=new Ext.util.KeyNav(b.inputEl,{scope:b,up:b.spinUp,down:b.spinDown})}if(b.mouseWheelEnabled){b.mon(b.bodyEl,"mousewheel",b.onMouseWheel,b)}},getSubTplMarkup:function(){var a=this,b=Ext.form.field.Base.prototype.getSubTplMarkup.apply(a,arguments);return'<table id="'+a.id+'-triggerWrap" class="'+Ext.baseCSSPrefix+'form-trigger-wrap" cellpadding="0" cellspacing="0"><tbody><tr><td id="'+a.id+'-inputCell" class="'+Ext.baseCSSPrefix+'form-trigger-input-cell">'+b+"</td>"+a.getTriggerMarkup()+"</tbody></table>"},getTriggerMarkup:function(){var a=this,b=(a.readOnly||a.hideTrigger);return a.getTpl("triggerTpl").apply({triggerStyle:"width:"+a.triggerWidth+(b?"px;display:none":"px")})},getTriggerWidth:function(){var b=this,a=0;if(b.triggerWrap&&!b.hideTrigger&&!b.readOnly){a=b.triggerWidth}return a},onTrigger1Click:function(){this.spinUp()},onTrigger2Click:function(){this.spinDown()},onTriggerWrapMouseup:function(){this.inputEl.focus()},spinUp:function(){var a=this;if(a.spinUpEnabled&&!a.disabled){a.fireEvent("spin",a,"up");a.fireEvent("spinup",a);a.onSpinUp()}},spinDown:function(){var a=this;if(a.spinDownEnabled&&!a.disabled){a.fireEvent("spin",a,"down");a.fireEvent("spindown",a);a.onSpinDown()}},setSpinUpEnabled:function(a){var b=this,c=b.spinUpEnabled;b.spinUpEnabled=a;if(c!==a&&b.rendered){b.spinUpEl[a?"removeCls":"addCls"](b.trigger1Cls+"-disabled")}},setSpinDownEnabled:function(a){var b=this,c=b.spinDownEnabled;b.spinDownEnabled=a;if(c!==a&&b.rendered){b.spinDownEl[a?"removeCls":"addCls"](b.trigger2Cls+"-disabled")}},onMouseWheel:function(b){var a=this,c;if(a.hasFocus){c=b.getWheelDelta();if(c>0){a.spinUp()}else{if(c<0){a.spinDown()}}b.stopEvent()}},onDestroy:function(){Ext.destroyMembers(this,"spinnerKeyNav","spinUpEl","spinDownEl");this.callParent()}});Ext.define("Ext.form.field.Number",{extend:"Ext.form.field.Spinner",alias:"widget.numberfield",alternateClassName:["Ext.form.NumberField","Ext.form.Number"],allowDecimals:true,decimalSeparator:".",submitLocaleSeparator:true,decimalPrecision:2,minValue:Number.NEGATIVE_INFINITY,maxValue:Number.MAX_VALUE,step:1,minText:"The minimum value for this field is {0}",maxText:"The maximum value for this field is {0}",nanText:"{0} is not a valid number",negativeText:"The value cannot be negative",baseChars:"0123456789",autoStripChars:false,initComponent:function(){var a=this,b;a.callParent();a.setMinValue(a.minValue);a.setMaxValue(a.maxValue);if(a.disableKeyFilter!==true){b=a.baseChars+"";if(a.allowDecimals){b+=a.decimalSeparator}if(a.minValue<0){b+="-"}b=Ext.String.escapeRegex(b);a.maskRe=new RegExp("["+b+"]");if(a.autoStripChars){a.stripCharsRe=new RegExp("[^"+b+"]","gi")}}},getErrors:function(c){var b=this,e=b.callParent(arguments),d=Ext.String.format,a;c=Ext.isDefined(c)?c:this.processRawValue(this.getRawValue());if(c.length<1){return e}c=String(c).replace(b.decimalSeparator,".");if(isNaN(c)){e.push(d(b.nanText,c))}a=b.parseValue(c);if(b.minValue===0&&a<0){e.push(this.negativeText)}else{if(a<b.minValue){e.push(d(b.minText,b.minValue))}}if(a>b.maxValue){e.push(d(b.maxText,b.maxValue))}return e},rawToValue:function(b){var a=this.fixPrecision(this.parseValue(b));if(a===null){a=b||null}return a},valueToRaw:function(c){var b=this,a=b.decimalSeparator;c=b.parseValue(c);c=b.fixPrecision(c);c=Ext.isNumber(c)?c:parseFloat(String(c).replace(a,"."));c=isNaN(c)?"":String(c).replace(".",a);return c},getSubmitValue:function(){var a=this,b=a.callParent();if(!a.submitLocaleSeparator){b=b.replace(a.decimalSeparator,".")}return b},onChange:function(){this.toggleSpinners();this.callParent(arguments)},toggleSpinners:function(){var b=this,c=b.getValue(),a=c===null;b.setSpinUpEnabled(a||c<b.maxValue);b.setSpinDownEnabled(a||c>b.minValue)},setMinValue:function(a){this.minValue=Ext.Number.from(a,Number.NEGATIVE_INFINITY);this.toggleSpinners()},setMaxValue:function(a){this.maxValue=Ext.Number.from(a,Number.MAX_VALUE);this.toggleSpinners()},parseValue:function(a){a=parseFloat(String(a).replace(this.decimalSeparator,"."));return isNaN(a)?null:a},fixPrecision:function(d){var c=this,b=isNaN(d),a=c.decimalPrecision;if(b||!d){return b?"":d}else{if(!c.allowDecimals||a<=0){a=0}}return parseFloat(Ext.Number.toFixed(parseFloat(d),a))},beforeBlur:function(){var b=this,a=b.parseValue(b.getRawValue());if(!Ext.isEmpty(a)){b.setValue(a)}},onSpinUp:function(){var a=this;if(!a.readOnly){a.setValue(Ext.Number.constrain(a.getValue()+a.step,a.minValue,a.maxValue))}},onSpinDown:function(){var a=this;if(!a.readOnly){a.setValue(Ext.Number.constrain(a.getValue()-a.step,a.minValue,a.maxValue))}}});Ext.define("Ext.toolbar.Paging",{extend:"Ext.toolbar.Toolbar",alias:"widget.pagingtoolbar",alternateClassName:"Ext.PagingToolbar",requires:["Ext.toolbar.TextItem","Ext.form.field.Number"],mixins:{bindable:"Ext.util.Bindable"},displayInfo:false,prependButtons:false,displayMsg:"Displaying {0} - {1} of {2}",emptyMsg:"No data to display",beforePageText:"Page",afterPageText:"of {0}",firstText:"First Page",prevText:"Previous Page",nextText:"Next Page",lastText:"Last Page",refreshText:"Refresh",inputItemWidth:30,getPagingItems:function(){var a=this;return[{itemId:"first",tooltip:a.firstText,overflowText:a.firstText,iconCls:Ext.baseCSSPrefix+"tbar-page-first",disabled:true,handler:a.moveFirst,scope:a},{itemId:"prev",tooltip:a.prevText,overflowText:a.prevText,iconCls:Ext.baseCSSPrefix+"tbar-page-prev",disabled:true,handler:a.movePrevious,scope:a},"-",a.beforePageText,{xtype:"numberfield",itemId:"inputItem",name:"inputItem",cls:Ext.baseCSSPrefix+"tbar-page-number",allowDecimals:false,minValue:1,hideTrigger:true,enableKeyEvents:true,keyNavEnabled:false,selectOnFocus:true,submitValue:false,isFormField:false,width:a.inputItemWidth,margins:"-1 2 3 2",listeners:{scope:a,keydown:a.onPagingKeyDown,blur:a.onPagingBlur}},{xtype:"tbtext",itemId:"afterTextItem",text:Ext.String.format(a.afterPageText,1)},"-",{itemId:"next",tooltip:a.nextText,overflowText:a.nextText,iconCls:Ext.baseCSSPrefix+"tbar-page-next",disabled:true,handler:a.moveNext,scope:a},{itemId:"last",tooltip:a.lastText,overflowText:a.lastText,iconCls:Ext.baseCSSPrefix+"tbar-page-last",disabled:true,handler:a.moveLast,scope:a},"-",{itemId:"refresh",tooltip:a.refreshText,overflowText:a.refreshText,iconCls:Ext.baseCSSPrefix+"tbar-loading",handler:a.doRefresh,scope:a}]},initComponent:function(){var b=this,c=b.getPagingItems(),a=b.items||b.buttons||[];if(b.prependButtons){b.items=a.concat(c)}else{b.items=c.concat(a)}delete b.buttons;if(b.displayInfo){b.items.push("->");b.items.push({xtype:"tbtext",itemId:"displayItem"})}b.callParent();b.addEvents("change","beforechange");b.on("beforerender",b.onLoad,b,{single:true});b.bindStore(b.store||"ext-empty-store",true)},updateInfo:function(){var e=this,c=e.child("#displayItem"),a=e.store,b=e.getPageData(),d,g;if(c){d=a.getCount();if(d===0){g=e.emptyMsg}else{g=Ext.String.format(e.displayMsg,b.fromRecord,b.toRecord,b.total)}c.setText(g)}},onLoad:function(){var g=this,d,b,c,a,e,h;e=g.store.getCount();h=e===0;if(!h){d=g.getPageData();b=d.currentPage;c=d.pageCount;a=Ext.String.format(g.afterPageText,isNaN(c)?1:c)}else{b=0;c=0;a=Ext.String.format(g.afterPageText,0)}Ext.suspendLayouts();g.child("#afterTextItem").setText(a);g.child("#inputItem").setDisabled(h).setValue(b);g.child("#first").setDisabled(b===1||h);g.child("#prev").setDisabled(b===1||h);g.child("#next").setDisabled(b===c||h);g.child("#last").setDisabled(b===c||h);g.child("#refresh").enable();g.updateInfo();Ext.resumeLayouts(true);if(g.rendered){g.fireEvent("change",g,d)}},getPageData:function(){var b=this.store,a=b.getTotalCount();return{total:a,currentPage:b.currentPage,pageCount:Math.ceil(a/b.pageSize),fromRecord:((b.currentPage-1)*b.pageSize)+1,toRecord:Math.min(b.currentPage*b.pageSize,a)}},onLoadError:function(){if(!this.rendered){return}this.child("#refresh").enable()},readPageFromInput:function(b){var a=this.child("#inputItem").getValue(),c=parseInt(a,10);if(!a||isNaN(c)){this.child("#inputItem").setValue(b.currentPage);return false}return c},onPagingFocus:function(){this.child("#inputItem").select()},onPagingBlur:function(b){var a=this.getPageData().currentPage;this.child("#inputItem").setValue(a)},onPagingKeyDown:function(i,h){var d=this,b=h.getKey(),c=d.getPageData(),a=h.shiftKey?10:1,g;if(b==h.RETURN){h.stopEvent();g=d.readPageFromInput(c);if(g!==false){g=Math.min(Math.max(1,g),c.pageCount);if(d.fireEvent("beforechange",d,g)!==false){d.store.loadPage(g)}}}else{if(b==h.HOME||b==h.END){h.stopEvent();g=b==h.HOME?1:c.pageCount;i.setValue(g)}else{if(b==h.UP||b==h.PAGE_UP||b==h.DOWN||b==h.PAGE_DOWN){h.stopEvent();g=d.readPageFromInput(c);if(g){if(b==h.DOWN||b==h.PAGE_DOWN){a*=-1}g+=a;if(g>=1&&g<=c.pageCount){i.setValue(g)}}}}}},beforeLoad:function(){if(this.rendered&&this.refresh){this.refresh.disable()}},moveFirst:function(){if(this.fireEvent("beforechange",this,1)!==false){this.store.loadPage(1)}},movePrevious:function(){var b=this,a=b.store.currentPage-1;if(a>0){if(b.fireEvent("beforechange",b,a)!==false){b.store.previousPage()}}},moveNext:function(){var c=this,b=c.getPageData().pageCount,a=c.store.currentPage+1;if(a<=b){if(c.fireEvent("beforechange",c,a)!==false){c.store.nextPage()}}},moveLast:function(){var b=this,a=b.getPageData().pageCount;if(b.fireEvent("beforechange",b,a)!==false){b.store.loadPage(a)}},doRefresh:function(){var a=this,b=a.store.currentPage;if(a.fireEvent("beforechange",a,b)!==false){a.store.loadPage(b)}},getStoreListeners:function(){return{beforeload:this.beforeLoad,load:this.onLoad,exception:this.onLoadError}},unbind:function(a){this.bindStore(null)},bind:function(a){this.bindStore(a)},onDestroy:function(){this.unbind();this.callParent()}});Ext.define("Ext.view.BoundList",{extend:"Ext.view.View",alias:"widget.boundlist",alternateClassName:"Ext.BoundList",requires:["Ext.layout.component.BoundList","Ext.toolbar.Paging"],pageSize:0,baseCls:Ext.baseCSSPrefix+"boundlist",itemCls:Ext.baseCSSPrefix+"boundlist-item",listItemCls:"",shadow:false,trackOver:true,refreshed:0,deferInitialRefresh:false,componentLayout:"boundlist",childEls:["listEl"],renderTpl:['<div id="{id}-listEl" class="{baseCls}-list-ct" style="overflow:auto"></div>',"{%","var me=values.$comp, pagingToolbar=me.pagingToolbar;","if (pagingToolbar) {","pagingToolbar.ownerLayout = me.componentLayout;","Ext.DomHelper.generateMarkup(pagingToolbar.getRenderTree(), out);","}","%}",{disableFormats:true}],initComponent:function(){var b=this,a=b.baseCls,c=b.itemCls;b.selectedItemCls=a+"-selected";b.overItemCls=a+"-item-over";b.itemSelector="."+c;if(b.floating){b.addCls(a+"-floating")}if(!b.tpl){b.tpl=new Ext.XTemplate('<ul><tpl for=".">','<li role="option" class="'+c+'">'+b.getInnerTpl(b.displayField)+"</li>","</tpl></ul>")}else{if(Ext.isString(b.tpl)){b.tpl=new Ext.XTemplate(b.tpl)}}if(b.pageSize){b.pagingToolbar=b.createPagingToolbar()}b.callParent()},beforeRender:function(){var a=this;a.callParent(arguments);if(a.up("menu")){a.addCls(Ext.baseCSSPrefix+"menu")}},getBubbleTarget:function(){return this.pickerField},getRefItems:function(){return this.pagingToolbar?[this.pagingToolbar]:[]},createPagingToolbar:function(){return Ext.widget("pagingtoolbar",{id:this.id+"-paging-toolbar",pageSize:this.pageSize,store:this.store,border:false,ownerCt:this,ownerLayout:this.getComponentLayout()})},finishRenderChildren:function(){var a=this.pagingToolbar;this.callParent(arguments);if(a){a.finishRender()}},refresh:function(){var b=this,a=b.pagingToolbar;b.callParent();if(b.rendered&&a&&a.rendered&&!b.preserveScrollOnRefresh){b.el.appendChild(a.el)}},bindStore:function(a,b){var c=this.pagingToolbar;this.callParent(arguments);if(c){c.bindStore(this.store,b)}},getTargetEl:function(){return this.listEl||this.el},getInnerTpl:function(a){return"{"+a+"}"},onDestroy:function(){Ext.destroyMembers(this,"pagingToolbar","listEl");this.callParent()}});Ext.define("Ext.view.BoundListKeyNav",{extend:"Ext.util.KeyNav",requires:"Ext.view.BoundList",constructor:function(b,a){var c=this;c.boundList=a.boundList;c.callParent([b,Ext.apply({},a,c.defaultHandlers)])},defaultHandlers:{up:function(){var e=this,b=e.boundList,d=b.all,g=b.highlightedItem,c=g?b.indexOf(g):-1,a=c>0?c-1:d.getCount()-1;e.highlightAt(a)},down:function(){var e=this,b=e.boundList,d=b.all,g=b.highlightedItem,c=g?b.indexOf(g):-1,a=c<d.getCount()-1?c+1:0;e.highlightAt(a)},pageup:function(){},pagedown:function(){},home:function(){this.highlightAt(0)},end:function(){var a=this;a.highlightAt(a.boundList.all.getCount()-1)},enter:function(a){this.selectHighlighted(a)}},highlightAt:function(b){var a=this.boundList,c=a.all.item(b);if(c){c=c.dom;a.highlightItem(c);a.getTargetEl().scrollChildIntoView(c,false)}},selectHighlighted:function(g){var d=this,b=d.boundList,c=b.highlightedItem,a=b.getSelectionModel();if(c){a.selectWithEvent(b.getRecord(c),g)}}});Ext.define("Ext.form.field.ComboBox",{extend:"Ext.form.field.Picker",requires:["Ext.util.DelayedTask","Ext.EventObject","Ext.view.BoundList","Ext.view.BoundListKeyNav","Ext.data.StoreManager","Ext.layout.component.field.ComboBox"],alternateClassName:"Ext.form.ComboBox",alias:["widget.combobox","widget.combo"],mixins:{bindable:"Ext.util.Bindable"},componentLayout:"combobox",triggerCls:Ext.baseCSSPrefix+"form-arrow-trigger",hiddenName:"",hiddenDataCls:Ext.baseCSSPrefix+"hide-display "+Ext.baseCSSPrefix+"form-data-hidden",fieldSubTpl:['<div class="{hiddenDataCls}" role="presentation"></div>','<input id="{id}" type="{type}" {inputAttrTpl} class="{fieldCls} {typeCls}" autocomplete="off"','<tpl if="value"> value="{[Ext.util.Format.htmlEncode(values.value)]}"</tpl>','<tpl if="name"> name="{name}"</tpl>','<tpl if="placeholder"> placeholder="{placeholder}"</tpl>','<tpl if="size"> size="{size}"</tpl>','<tpl if="maxLength !== undefined"> maxlength="{maxLength}"</tpl>','<tpl if="readOnly"> readonly="readonly"</tpl>','<tpl if="disabled"> disabled="disabled"</tpl>','<tpl if="tabIdx"> tabIndex="{tabIdx}"</tpl>','<tpl if="fieldStyle"> style="{fieldStyle}"</tpl>',"/>",{compiled:true,disableFormats:true}],getSubTplData:function(){var a=this;Ext.applyIf(a.subTplData,{hiddenDataCls:a.hiddenDataCls});return a.callParent(arguments)},afterRender:function(){var a=this;a.callParent(arguments);a.setHiddenValue(a.value)},multiSelect:false,delimiter:", ",displayField:"text",triggerAction:"all",allQuery:"",queryParam:"query",queryMode:"remote",queryCaching:true,pageSize:0,autoSelect:true,typeAhead:false,typeAheadDelay:250,selectOnTab:true,forceSelection:false,growToLongestValue:true,defaultListConfig:{loadingHeight:70,minWidth:70,maxHeight:300,shadow:"sides"},ignoreSelection:0,removingRecords:null,resizeComboToGrow:function(){var a=this;return a.grow&&a.growToLongestValue},initComponent:function(){var e=this,c=Ext.isDefined,b=e.store,d=e.transform,a,g;Ext.applyIf(e.renderSelectors,{hiddenDataEl:"."+e.hiddenDataCls.split(" ").join(".")});this.addEvents("beforequery","select","beforeselect","beforedeselect");if(d){a=Ext.getDom(d);if(a){if(!e.store){b=Ext.Array.map(Ext.Array.from(a.options),function(h){return[h.value,h.text]})}if(!e.name){e.name=a.name}if(!("value" in e)){e.value=a.value}}}e.bindStore(b||"ext-empty-store",true);b=e.store;if(b.autoCreated){e.queryMode="local";e.valueField=e.displayField="field1";if(!b.expanded){e.displayField="field2"}}if(!c(e.valueField)){e.valueField=e.displayField}g=e.queryMode==="local";if(!c(e.queryDelay)){e.queryDelay=g?10:500}if(!c(e.minChars)){e.minChars=g?0:4}if(!e.displayTpl){e.displayTpl=new Ext.XTemplate('<tpl for=".">{[typeof values === "string" ? values : values["'+e.displayField+'"]]}<tpl if="xindex < xcount">'+e.delimiter+"</tpl></tpl>")}else{if(Ext.isString(e.displayTpl)){e.displayTpl=new Ext.XTemplate(e.displayTpl)}}e.callParent();e.doQueryTask=new Ext.util.DelayedTask(e.doRawQuery,e);if(e.store.getCount()>0){e.setValue(e.value)}if(a){e.render(a.parentNode,a);Ext.removeNode(a);delete e.renderTo}},getStore:function(){return this.store},beforeBlur:function(){this.doQueryTask.cancel();this.assertValue()},assertValue:function(){var a=this,b=a.getRawValue(),c;if(a.forceSelection){if(a.multiSelect){if(b!==a.getDisplayValue()){a.setValue(a.lastSelection)}}else{c=a.findRecordByDisplay(b);if(c){a.select(c)}else{a.setValue(a.lastSelection)}}}a.collapse()},onTypeAhead:function(){var e=this,d=e.displayField,b=e.store.findRecord(d,e.getRawValue()),c=e.getPicker(),g,a,h;if(b){g=b.get(d);a=g.length;h=e.getRawValue().length;c.highlightItem(c.getNode(b));if(h!==0&&h!==a){e.setRawValue(g);e.selectText(h,g.length)}}},resetToDefault:Ext.emptyFn,beforeReset:function(){this.callParent();this.clearFilter()},onUnbindStore:function(a){var b=this.picker;if(!a&&b){b.bindStore(null)}this.clearFilter()},onBindStore:function(a,c){var b=this.picker;if(!c){this.resetToDefault()}if(b){b.bindStore(a)}},getStoreListeners:function(){var a=this;return{beforeload:a.onBeforeLoad,clear:a.onClear,datachanged:a.onDataChanged,load:a.onLoad,exception:a.onException,remove:a.onRemove}},onBeforeLoad:function(){++this.ignoreSelection},onDataChanged:function(){var a=this;if(a.resizeComboToGrow()){a.updateLayout()}},onClear:function(){var a=this;if(a.resizeComboToGrow()){a.removingRecords=true;a.onDataChanged()}},onRemove:function(){var a=this;if(a.resizeComboToGrow()){a.removingRecords=true}},onException:function(){if(this.ignoreSelection>0){--this.ignoreSelection}this.collapse()},onLoad:function(){var a=this,b=a.value;if(a.ignoreSelection>0){--a.ignoreSelection}if(a.rawQuery){a.rawQuery=false;a.syncSelection();if(a.picker&&!a.picker.getSelectionModel().hasSelection()){a.doAutoSelect()}}else{if(a.value||a.value===0){a.setValue(a.value)}else{if(a.store.getCount()){a.doAutoSelect()}else{a.setValue(a.value)}}}},doRawQuery:function(){this.doQuery(this.getRawValue(),false,true)},doQuery:function(i,d,g){i=i||"";var e=this,b={query:i,forceAll:d,combo:e,cancel:false},a=e.store,h=e.queryMode==="local",c;if(e.fireEvent("beforequery",b)===false||b.cancel){return false}i=b.query;d=b.forceAll;if(d||(i.length>=e.minChars)){e.expand();if(!e.queryCaching||e.lastQuery!==i){e.lastQuery=i;if(h){a.suspendEvents();c=e.clearFilter();if(i||!d){e.activeFilter=new Ext.util.Filter({root:"data",property:e.displayField,value:i});a.filter(e.activeFilter);c=true}else{delete e.activeFilter}a.resumeEvents();if(e.rendered&&c){e.getPicker().refresh()}}else{e.rawQuery=g;if(e.pageSize){e.loadPage(1)}else{a.load({params:e.getParams(i)})}}}if(e.getRawValue()!==e.getDisplayValue()){e.ignoreSelection++;e.picker.getSelectionModel().deselectAll();e.ignoreSelection--}if(h){e.doAutoSelect()}if(e.typeAhead){e.doTypeAhead()}}return true},clearFilter:function(){var a=this.store,c=this.activeFilter,d=a.filters,b;if(c){if(d.getCount()>1){d.remove(c);b=d.getRange()}a.clearFilter(true);if(b){a.filter(b)}}return !!c},loadPage:function(a){this.store.loadPage(a,{params:this.getParams(this.lastQuery)})},onPageChange:function(b,a){this.loadPage(a);return false},getParams:function(c){var b={},a=this.queryParam;if(a){b[a]=c}return b},doAutoSelect:function(){var b=this,a=b.picker,c,d;if(a&&b.autoSelect&&b.store.getCount()>0){c=a.getSelectionModel().lastSelected;d=a.getNode(c||0);if(d){a.highlightItem(d);a.listEl.scrollChildIntoView(d,false)}}},doTypeAhead:function(){if(!this.typeAheadTask){this.typeAheadTask=new Ext.util.DelayedTask(this.onTypeAhead,this)}if(this.lastKey!=Ext.EventObject.BACKSPACE&&this.lastKey!=Ext.EventObject.DELETE){this.typeAheadTask.delay(this.typeAheadDelay)}},onTriggerClick:function(){var a=this;if(!a.readOnly&&!a.disabled){if(a.isExpanded){a.collapse()}else{a.onFocus({});if(a.triggerAction==="all"){a.doQuery(a.allQuery,true)}else{a.doQuery(a.getRawValue(),false,true)}}a.inputEl.focus()}},onKeyUp:function(d,b){var c=this,a=d.getKey();if(!c.readOnly&&!c.disabled&&c.editable){c.lastKey=a;if(!d.isSpecialKey()||a==d.BACKSPACE||a==d.DELETE){c.doQueryTask.delay(c.queryDelay)}}if(c.enableKeyEvents){c.callParent(arguments)}},initEvents:function(){var a=this;a.callParent();if(!a.enableKeyEvents){a.mon(a.inputEl,"keyup",a.onKeyUp,a)}},onDestroy:function(){this.bindStore(null);this.callParent()},onAdded:function(){var a=this;a.callParent(arguments);if(a.picker){a.picker.ownerCt=a.up("[floating]");a.picker.registerWithOwnerCt()}},createPicker:function(){var c=this,b,a=Ext.apply({xtype:"boundlist",pickerField:c,selModel:{mode:c.multiSelect?"SIMPLE":"SINGLE"},floating:true,hidden:true,store:c.store,displayField:c.displayField,focusOnToFront:false,pageSize:c.pageSize,tpl:c.tpl},c.listConfig,c.defaultListConfig);b=c.picker=Ext.widget(a);if(c.pageSize){b.pagingToolbar.on("beforechange",c.onPageChange,c)}c.mon(b,{itemclick:c.onItemClick,refresh:c.onListRefresh,scope:c});c.mon(b.getSelectionModel(),{beforeselect:c.onBeforeSelect,beforedeselect:c.onBeforeDeselect,selectionchange:c.onListSelectionChange,scope:c});return b},alignPicker:function(){var b=this,a=b.getPicker(),e=b.getPosition()[1]-Ext.getBody().getScroll().top,d=Ext.Element.getViewHeight()-e-b.getHeight(),c=Math.max(e,d);if(a.height){delete a.height;a.updateLayout()}if(a.getHeight()>c-5){a.setHeight(c-5)}b.callParent()},onListRefresh:function(){this.alignPicker();this.syncSelection()},onItemClick:function(c,a){var e=this,d=e.picker.getSelectionModel().getSelection(),b=e.valueField;if(!e.multiSelect&&d.length){if(a.get(b)===d[0].get(b)){e.displayTplData=[a.data];e.setRawValue(e.getDisplayValue());e.collapse()}}},onBeforeSelect:function(b,a){return this.fireEvent("beforeselect",this,a,a.index)},onBeforeDeselect:function(b,a){return this.fireEvent("beforedeselect",this,a,a.index)},onListSelectionChange:function(b,d){var a=this,e=a.multiSelect,c=d.length>0;if(!a.ignoreSelection&&a.isExpanded){if(!e){Ext.defer(a.collapse,1,a)}if(e||c){a.setValue(d,false)}if(c){a.fireEvent("select",a,d)}a.inputEl.focus()}},onExpand:function(){var d=this,a=d.listKeyNav,c=d.selectOnTab,b=d.getPicker();if(a){a.enable()}else{a=d.listKeyNav=new Ext.view.BoundListKeyNav(this.inputEl,{boundList:b,forceKeyDown:true,tab:function(g){if(c){this.selectHighlighted(g);d.triggerBlur()}return true}})}if(c){d.ignoreMonitorTab=true}Ext.defer(a.enable,1,a);d.inputEl.focus()},onCollapse:function(){var b=this,a=b.listKeyNav;if(a){a.disable();b.ignoreMonitorTab=false}},select:function(a){this.setValue(a,true)},findRecord:function(d,c){var b=this.store,a=b.findExact(d,c);return a!==-1?b.getAt(a):false},findRecordByValue:function(a){return this.findRecord(this.valueField,a)},findRecordByDisplay:function(a){return this.findRecord(this.displayField,a)},setValue:function(m,e){var k=this,c=k.valueNotFoundText,n=k.inputEl,g,j,h,a,l=[],b=[],d=[];if(k.store.loading){k.value=m;k.setHiddenValue(k.value);return k}m=Ext.Array.from(m);for(g=0,j=m.length;g<j;g++){h=m[g];if(!h||!h.isModel){h=k.findRecordByValue(h)}if(h){l.push(h);b.push(h.data);d.push(h.get(k.valueField))}else{if(!k.forceSelection){d.push(m[g]);a={};a[k.displayField]=m[g];b.push(a)}else{if(Ext.isDefined(c)){b.push(c)}}}}k.setHiddenValue(d);k.value=k.multiSelect?d:d[0];if(!Ext.isDefined(k.value)){k.value=null}k.displayTplData=b;k.lastSelection=k.valueModels=l;if(n&&k.emptyText&&!Ext.isEmpty(m)){n.removeCls(k.emptyCls)}k.setRawValue(k.getDisplayValue());k.checkChange();if(e!==false){k.syncSelection()}k.applyEmptyText();return k},setHiddenValue:function(j){var e=this,a=e.hiddenName,d,b,k,h,g,c;if(!e.hiddenDataEl||!a){return}j=Ext.Array.from(j);b=e.hiddenDataEl.dom;k=b.childNodes;h=k[0];g=j.length;c=k.length;if(!h&&g>0){e.hiddenDataEl.update(Ext.DomHelper.markup({tag:"input",type:"hidden",name:a}));c=1;h=b.firstChild}while(c>g){b.removeChild(k[0]);--c}while(c<g){b.appendChild(h.cloneNode(true));++c}for(d=0;d<g;d++){k[d].value=j[d]}},getDisplayValue:function(){return this.displayTpl.apply(this.displayTplData)},getValue:function(){var b=this,a=b.picker,d=b.getRawValue(),c=b.value;if(b.getDisplayValue()!==d){c=d;b.value=b.displayTplData=b.valueModels=null;if(a){b.ignoreSelection++;a.getSelectionModel().deselectAll();b.ignoreSelection--}}return c},getSubmitValue:function(){return this.getValue()},isEqual:function(e,d){var b=Ext.Array.from,c,a;e=b(e);d=b(d);a=e.length;if(a!==d.length){return false}for(c=0;c<a;c++){if(d[c]!==e[c]){return false}}return true},clearValue:function(){this.setValue([])},syncSelection:function(){var h=this,d=h.picker,g,c,b=h.valueModels||[],e=b.length,a,i;if(d){g=[];for(a=0;a<e;a++){i=b[a];if(i&&i.isModel&&h.store.indexOf(i)>=0){g.push(i)}}h.ignoreSelection++;c=d.getSelectionModel();c.deselectAll();if(g.length){c.select(g)}h.ignoreSelection--}},onEditorTab:function(b){var a=this.listKeyNav;if(this.selectOnTab&&a){a.selectHighlighted(b)}}});Ext.define("Ext.picker.Month",{extend:"Ext.Component",requires:["Ext.XTemplate","Ext.util.ClickRepeater","Ext.Date","Ext.button.Button"],alias:"widget.monthpicker",alternateClassName:"Ext.MonthPicker",childEls:["bodyEl","prevEl","nextEl","buttonsEl","monthEl","yearEl"],renderTpl:['<div id="{id}-bodyEl" class="{baseCls}-body">','<div id="{id}-monthEl" class="{baseCls}-months">','<tpl for="months">','<div class="{parent.baseCls}-item {parent.baseCls}-month"><a style="{parent.monthStyle}" href="#" hidefocus="on">{.}</a></div>',"</tpl>","</div>",'<div id="{id}-yearEl" class="{baseCls}-years">','<div class="{baseCls}-yearnav">','<button id="{id}-prevEl" class="{baseCls}-yearnav-prev"></button>','<button id="{id}-nextEl" class="{baseCls}-yearnav-next"></button>',"</div>",'<tpl for="years">','<div class="{parent.baseCls}-item {parent.baseCls}-year"><a href="#" hidefocus="on">{.}</a></div>',"</tpl>","</div>",'<div class="'+Ext.baseCSSPrefix+'clear"></div>',"</div>",'<tpl if="showButtons">','<div id="{id}-buttonsEl" class="{baseCls}-buttons">{%',"var me=values.$comp, okBtn=me.okBtn, cancelBtn=me.cancelBtn;","okBtn.ownerLayout = cancelBtn.ownerLayout = me.componentLayout;","okBtn.ownerCt = cancelBtn.ownerCt = me;","Ext.DomHelper.generateMarkup(okBtn.getRenderTree(), out);","Ext.DomHelper.generateMarkup(cancelBtn.getRenderTree(), out);","%}</div>","</tpl>"],okText:"OK",cancelText:"Cancel",baseCls:Ext.baseCSSPrefix+"monthpicker",showButtons:true,width:178,measureWidth:35,measureMaxHeight:20,smallCls:Ext.baseCSSPrefix+"monthpicker-small",totalYears:10,yearOffset:5,monthOffset:6,initComponent:function(){var a=this;a.selectedCls=a.baseCls+"-selected";a.addEvents("cancelclick","monthclick","monthdblclick","okclick","select","yearclick","yeardblclick");if(a.small){a.addCls(a.smallCls)}a.setValue(a.value);a.activeYear=a.getYear(new Date().getFullYear()-4,-4);if(a.showButtons){a.okBtn=new Ext.button.Button({text:a.okText,handler:a.onOkClick,scope:a});a.cancelBtn=new Ext.button.Button({text:a.cancelText,handler:a.onCancelClick,scope:a})}this.callParent()},beforeRender:function(){var g=this,c=0,b=[],a=Ext.Date.getShortMonthName,e=g.monthOffset,h=g.monthMargin,d="";g.callParent();for(;c<e;++c){b.push(a(c),a(c+e))}if(Ext.isDefined(h)){d="margin: 0 "+h+"px;"}Ext.apply(g.renderData,{months:b,years:g.getYears(),showButtons:g.showButtons,monthStyle:d})},afterRender:function(){var b=this,a=b.bodyEl,c=b.buttonsEl;b.callParent();b.mon(a,"click",b.onBodyClick,b);b.mon(a,"dblclick",b.onBodyClick,b);b.years=a.select("."+b.baseCls+"-year a");b.months=a.select("."+b.baseCls+"-month a");b.backRepeater=new Ext.util.ClickRepeater(b.prevEl,{handler:Ext.Function.bind(b.adjustYear,b,[-b.totalYears])});b.prevEl.addClsOnOver(b.baseCls+"-yearnav-prev-over");b.nextRepeater=new Ext.util.ClickRepeater(b.nextEl,{handler:Ext.Function.bind(b.adjustYear,b,[b.totalYears])});b.nextEl.addClsOnOver(b.baseCls+"-yearnav-next-over");b.updateBody();if(!Ext.isDefined(b.monthMargin)){Ext.picker.Month.prototype.monthMargin=b.calculateMonthMargin()}},calculateMonthMargin:function(){var d=this,b=d.monthEl,a=d.months,e=a.first(),c=e.getMargin("l");while(c&&d.getLargest()>d.measureMaxHeight){--c;a.setStyle("margin","0 "+c+"px")}return c},getLargest:function(a){var b=0;this.months.each(function(d){var c=d.getHeight();if(c>b){b=c}});return b},setValue:function(d){var c=this,e=c.activeYear,g=c.monthOffset,b,a;if(!d){c.value=[null,null]}else{if(Ext.isDate(d)){c.value=[d.getMonth(),d.getFullYear()]}else{c.value=[d[0],d[1]]}}if(c.rendered){b=c.value[1];if(b!==null){if((b<e||b>e+c.yearOffset)){c.activeYear=b-c.yearOffset+1}}c.updateBody()}return c},getValue:function(){return this.value},hasSelection:function(){var a=this.value;return a[0]!==null&&a[1]!==null},getYears:function(){var d=this,e=d.yearOffset,g=d.activeYear,a=g+e,c=g,b=[];for(;c<a;++c){b.push(c,c+e)}return b},updateBody:function(){var i=this,e=i.years,b=i.months,m=i.getYears(),n=i.selectedCls,k=i.getYear(null),g=i.value[0],l=i.monthOffset,h,d,j,a,c;if(i.rendered){e.removeCls(n);b.removeCls(n);d=e.elements;a=d.length;for(j=0;j<a;j++){c=Ext.fly(d[j]);h=m[j];c.dom.innerHTML=h;if(h==k){c.dom.className=n}}if(g!==null){if(g<l){g=g*2}else{g=(g-l)*2+1}b.item(g).addCls(n)}}},getYear:function(a,c){var b=this.value[1];c=c||0;return b===null?a:b+c},onBodyClick:function(d,b){var c=this,a=d.type=="dblclick";if(d.getTarget("."+c.baseCls+"-month")){d.stopEvent();c.onMonthClick(b,a)}else{if(d.getTarget("."+c.baseCls+"-year")){d.stopEvent();c.onYearClick(b,a)}}},adjustYear:function(a){if(typeof a!="number"){a=this.totalYears}this.activeYear+=a;this.updateBody()},onOkClick:function(){this.fireEvent("okclick",this,this.value)},onCancelClick:function(){this.fireEvent("cancelclick",this)},onMonthClick:function(c,a){var b=this;b.value[0]=b.resolveOffset(b.months.indexOf(c),b.monthOffset);b.updateBody();b.fireEvent("month"+(a?"dbl":"")+"click",b,b.value);b.fireEvent("select",b,b.value)},onYearClick:function(c,a){var b=this;b.value[1]=b.activeYear+b.resolveOffset(b.years.indexOf(c),b.yearOffset);b.updateBody();b.fireEvent("year"+(a?"dbl":"")+"click",b,b.value);b.fireEvent("select",b,b.value)},resolveOffset:function(a,b){if(a%2===0){return(a/2)}else{return b+Math.floor(a/2)}},beforeDestroy:function(){var a=this;a.years=a.months=null;Ext.destroyMembers(a,"backRepeater","nextRepeater","okBtn","cancelBtn");a.callParent()},finishRenderChildren:function(){var a=this;this.callParent(arguments);if(this.showButtons){a.okBtn.finishRender();a.cancelBtn.finishRender()}},onDestroy:function(){Ext.destroyMembers(this,"okBtn","cancelBtn");this.callParent()}});Ext.define("Ext.picker.Date",{extend:"Ext.Component",requires:["Ext.XTemplate","Ext.button.Button","Ext.button.Split","Ext.util.ClickRepeater","Ext.util.KeyNav","Ext.EventObject","Ext.fx.Manager","Ext.picker.Month"],alias:"widget.datepicker",alternateClassName:"Ext.DatePicker",childEls:["innerEl","eventEl","prevEl","nextEl","middleBtnEl","footerEl"],border:true,renderTpl:['<div id="{id}-innerEl" role="grid">','<div role="presentation" class="{baseCls}-header">','<div class="{baseCls}-prev"><a id="{id}-prevEl" href="#" role="button" title="{prevText}"></a></div>','<div class="{baseCls}-month" id="{id}-middleBtnEl">{%this.renderMonthBtn(values, out)%}</div>','<div class="{baseCls}-next"><a id="{id}-nextEl" href="#" role="button" title="{nextText}"></a></div>',"</div>",'<table id="{id}-eventEl" class="{baseCls}-inner" cellspacing="0" role="presentation">','<thead role="presentation"><tr role="presentation">','<tpl for="dayNames">','<th role="columnheader" title="{.}"><span>{.:this.firstInitial}</span></th>',"</tpl>","</tr></thead>",'<tbody role="presentation"><tr role="presentation">','<tpl for="days">',"{#:this.isEndOfWeek}",'<td role="gridcell" id="{[Ext.id()]}">','<a role="presentation" href="#" hidefocus="on" class="{parent.baseCls}-date" tabIndex="1">','<em role="presentation"><span role="presentation"></span></em>',"</a>","</td>","</tpl>","</tr></tbody>","</table>",'<tpl if="showToday">','<div id="{id}-footerEl" role="presentation" class="{baseCls}-footer">{%this.renderTodayBtn(values, out)%}</div>',"</tpl>","</div>",{firstInitial:function(a){return Ext.picker.Date.prototype.getDayInitial(a)},isEndOfWeek:function(b){b--;var a=b%7===0&&b!==0;return a?'</tr><tr role="row">':""},renderTodayBtn:function(a,b){Ext.DomHelper.generateMarkup(a.$comp.todayBtn.getRenderTree(),b)},renderMonthBtn:function(a,b){Ext.DomHelper.generateMarkup(a.$comp.monthBtn.getRenderTree(),b)}}],todayText:"Today",ariaTitle:"Date Picker: {0}",ariaTitleDateFormat:"F d, Y",todayTip:"{0} (Spacebar)",minText:"This date is before the minimum date",maxText:"This date is after the maximum date",disabledDaysText:"Disabled",disabledDatesText:"Disabled",nextText:"Next Month (Control+Right)",prevText:"Previous Month (Control+Left)",monthYearText:"Choose a month (Control+Up/Down to move years)",monthYearFormat:"F Y",startDay:0,showToday:true,disableAnim:false,baseCls:Ext.baseCSSPrefix+"datepicker",longDayFormat:"F d, Y",focusOnShow:false,focusOnSelect:true,width:178,initHour:12,numDays:42,initComponent:function(){var b=this,a=Ext.Date.clearTime;b.selectedCls=b.baseCls+"-selected";b.disabledCellCls=b.baseCls+"-disabled";b.prevCls=b.baseCls+"-prevday";b.activeCls=b.baseCls+"-active";b.nextCls=b.baseCls+"-prevday";b.todayCls=b.baseCls+"-today";b.dayNames=b.dayNames.slice(b.startDay).concat(b.dayNames.slice(0,b.startDay));b.listeners=Ext.apply(b.listeners||{},{mousewheel:{element:"eventEl",fn:b.handleMouseWheel,scope:b},click:{element:"eventEl",fn:b.handleDateClick,scope:b,delegate:"a."+b.baseCls+"-date"}});this.callParent();b.value=b.value?a(b.value,true):a(new Date());b.addEvents("select");b.initDisabledDays()},beforeRender:function(){var b=this,c=new Array(b.numDays),a=Ext.Date.format(new Date(),b.format);if(b.up("menu")){b.addCls(Ext.baseCSSPrefix+"menu")}b.monthBtn=new Ext.button.Split({ownerCt:b,ownerLayout:b.getComponentLayout(),text:"",tooltip:b.monthYearText,listeners:{click:b.showMonthPicker,arrowclick:b.showMonthPicker,scope:b}});if(this.showToday){b.todayBtn=new Ext.button.Button({ownerCt:b,ownerLayout:b.getComponentLayout(),text:Ext.String.format(b.todayText,a),tooltip:Ext.String.format(b.todayTip,a),tooltipType:"title",handler:b.selectToday,scope:b})}b.callParent();Ext.applyIf(b,{renderData:{}});Ext.apply(b.renderData,{dayNames:b.dayNames,showToday:b.showToday,prevText:b.prevText,nextText:b.nextText,days:c})},finishRenderChildren:function(){var a=this;a.callParent();a.monthBtn.finishRender();if(a.showToday){a.todayBtn.finishRender()}},onRender:function(b,a){var c=this;c.callParent(arguments);c.el.unselectable();c.cells=c.eventEl.select("tbody td");c.textNodes=c.eventEl.query("tbody td span")},initEvents:function(){var c=this,a=Ext.Date,b=a.DAY;c.callParent();c.prevRepeater=new Ext.util.ClickRepeater(c.prevEl,{handler:c.showPrevMonth,scope:c,preventDefault:true,stopDefault:true});c.nextRepeater=new Ext.util.ClickRepeater(c.nextEl,{handler:c.showNextMonth,scope:c,preventDefault:true,stopDefault:true});c.keyNav=new Ext.util.KeyNav(c.eventEl,Ext.apply({scope:c,left:function(d){if(d.ctrlKey){c.showPrevMonth()}else{c.update(a.add(c.activeDate,b,-1))}},right:function(d){if(d.ctrlKey){c.showNextMonth()}else{c.update(a.add(c.activeDate,b,1))}},up:function(d){if(d.ctrlKey){c.showNextYear()}else{c.update(a.add(c.activeDate,b,-7))}},down:function(d){if(d.ctrlKey){c.showPrevYear()}else{c.update(a.add(c.activeDate,b,7))}},pageUp:c.showNextMonth,pageDown:c.showPrevMonth,enter:function(d){d.stopPropagation();return true}},c.keyNavConfig));if(c.showToday){c.todayKeyListener=c.eventEl.addKeyListener(Ext.EventObject.SPACE,c.selectToday,c)}c.update(c.value)},initDisabledDays:function(){var h=this,b=h.disabledDates,g="(?:",a,i,c,e;if(!h.disabledDatesRE&&b){a=b.length-1;c=b.length;for(i=0;i<c;i++){e=b[i];g+=Ext.isDate(e)?"^"+Ext.String.escapeRegex(Ext.Date.dateFormat(e,h.format))+"$":e;if(i!=a){g+="|"}}h.disabledDatesRE=new RegExp(g+")")}},setDisabledDates:function(a){var b=this;if(Ext.isArray(a)){b.disabledDates=a;b.disabledDatesRE=null}else{b.disabledDatesRE=a}b.initDisabledDays();b.update(b.value,true);return b},setDisabledDays:function(a){this.disabledDays=a;return this.update(this.value,true)},setMinDate:function(a){this.minDate=a;return this.update(this.value,true)},setMaxDate:function(a){this.maxDate=a;return this.update(this.value,true)},setValue:function(a){this.value=Ext.Date.clearTime(a,true);return this.update(this.value)},getValue:function(){return this.value},getDayInitial:function(a){return a.substr(0,1)},focus:function(){this.update(this.activeDate)},onEnable:function(){this.callParent();this.setDisabledStatus(false);this.update(this.activeDate)},onDisable:function(){this.callParent();this.setDisabledStatus(true)},setDisabledStatus:function(a){var b=this;b.keyNav.setDisabled(a);b.prevRepeater.setDisabled(a);b.nextRepeater.setDisabled(a);if(b.showToday){b.todayKeyListener.setDisabled(a);b.todayBtn.setDisabled(a)}},getActive:function(){return this.activeDate||this.value},runAnimation:function(c){var b=this.monthPicker,a={duration:200,callback:function(){if(c){b.hide()}else{b.show()}}};if(c){b.el.slideOut("t",a)}else{b.el.slideIn("t",a)}},hideMonthPicker:function(a){var c=this,b=c.monthPicker;if(b){if(c.shouldAnimate(a)){c.runAnimation(true)}else{b.hide()}}return c},showMonthPicker:function(a){var c=this,b;if(c.rendered&&!c.disabled){b=c.createMonthPicker();b.setValue(c.getActive());b.setSize(c.getSize());b.setPosition(-1,-1);if(c.shouldAnimate(a)){c.runAnimation(false)}else{b.show()}}return c},shouldAnimate:function(a){return Ext.isDefined(a)?a:!this.disableAnim},createMonthPicker:function(){var b=this,a=b.monthPicker;if(!a){b.monthPicker=a=new Ext.picker.Month({renderTo:b.el,floating:true,shadow:false,small:b.showToday===false,listeners:{scope:b,cancelclick:b.onCancelClick,okclick:b.onOkClick,yeardblclick:b.onOkClick,monthdblclick:b.onOkClick}});if(!b.disableAnim){a.el.setStyle("display","none")}b.on("beforehide",Ext.Function.bind(b.hideMonthPicker,b,[false]))}return a},onOkClick:function(b,e){var d=this,g=e[0],c=e[1],a=new Date(c,g,d.getActive().getDate());if(a.getMonth()!==g){a=Ext.Date.getLastDateOfMonth(new Date(c,g,1))}d.update(a);d.hideMonthPicker()},onCancelClick:function(){this.selectedUpdate(this.activeDate);this.hideMonthPicker()},showPrevMonth:function(a){return this.update(Ext.Date.add(this.activeDate,Ext.Date.MONTH,-1))},showNextMonth:function(a){return this.update(Ext.Date.add(this.activeDate,Ext.Date.MONTH,1))},showPrevYear:function(){this.update(Ext.Date.add(this.activeDate,Ext.Date.YEAR,-1))},showNextYear:function(){this.update(Ext.Date.add(this.activeDate,Ext.Date.YEAR,1))},handleMouseWheel:function(a){a.stopEvent();if(!this.disabled){var b=a.getWheelDelta();if(b>0){this.showPrevMonth()}else{if(b<0){this.showNextMonth()}}}},handleDateClick:function(d,a){var c=this,b=c.handler;d.stopEvent();if(!c.disabled&&a.dateValue&&!Ext.fly(a.parentNode).hasCls(c.disabledCellCls)){c.doCancelFocus=c.focusOnSelect===false;c.setValue(new Date(a.dateValue));delete c.doCancelFocus;c.fireEvent("select",c,c.value);if(b){b.call(c.scope||c,c,c.value)}c.onSelect()}},onSelect:function(){if(this.hideOnSelect){this.hide()}},selectToday:function(){var c=this,a=c.todayBtn,b=c.handler;if(a&&!a.disabled){c.setValue(Ext.Date.clearTime(new Date()));c.fireEvent("select",c,c.value);if(b){b.call(c.scope||c,c,c.value)}c.onSelect()}return c},selectedUpdate:function(a){var d=this,i=a.getTime(),j=d.cells,k=d.selectedCls,g=j.elements,b,e=g.length,h;j.removeCls(k);for(b=0;b<e;b++){h=Ext.fly(g[b]);if(h.dom.firstChild.dateValue==i){d.fireEvent("highlightitem",d,h);h.addCls(k);if(d.isVisible()&&!d.doCancelFocus){Ext.fly(h.dom.firstChild).focus(50)}break}}},fullUpdate:function(A){var E=this,g=E.cells.elements,d=E.textNodes,G=E.disabledCellCls,n=Ext.Date,w=0,D=0,e=E.isVisible(),u=+n.clearTime(A,true),z=+n.clearTime(new Date()),t=E.minDate?n.clearTime(E.minDate,true):Number.NEGATIVE_INFINITY,v=E.maxDate?n.clearTime(E.maxDate,true):Number.POSITIVE_INFINITY,C=E.disabledDatesRE,s=E.disabledDatesText,H=E.disabledDays?E.disabledDays.join(""):false,B=E.disabledDaysText,x=E.format,l=n.getDaysInMonth(A),p=n.getFirstDateOfMonth(A),h=p.getDay()-E.startDay,y=n.add(A,n.MONTH,-1),b=E.longDayFormat,k,q,a,F,m,o,c,j,r;if(h<0){h+=7}l+=h;k=n.getDaysInMonth(y)-h;q=new Date(y.getFullYear(),y.getMonth(),k,E.initHour);if(E.showToday){F=n.clearTime(new Date());a=(F<t||F>v||(C&&x&&C.test(n.dateFormat(F,x)))||(H&&H.indexOf(F.getDay())!=-1));if(!E.disabled){E.todayBtn.setDisabled(a);E.todayKeyListener.setDisabled(a)}}m=function(i){r=+n.clearTime(q,true);i.title=n.format(q,b);i.firstChild.dateValue=r;if(r==z){i.className+=" "+E.todayCls;i.title=E.todayText}if(r==u){i.className+=" "+E.selectedCls;E.fireEvent("highlightitem",E,i);if(e&&E.floating){Ext.fly(i.firstChild).focus(50)}}if(r<t){i.className=G;i.title=E.minText;return}if(r>v){i.className=G;i.title=E.maxText;return}if(H){if(H.indexOf(q.getDay())!=-1){i.title=B;i.className=G}}if(C&&x){j=n.dateFormat(q,x);if(C.test(j)){i.title=s.replace("%0",j);i.className=G}}};for(;w<E.numDays;++w){if(w<h){o=(++k);c=E.prevCls}else{if(w>=l){o=(++D);c=E.nextCls}else{o=w-h+1;c=E.activeCls}}d[w].innerHTML=o;g[w].className=c;q.setDate(q.getDate()+1);m(g[w])}E.monthBtn.setText(Ext.Date.format(A,E.monthYearFormat))},update:function(a,d){var b=this,c=b.activeDate;if(b.rendered){b.activeDate=a;if(!d&&c&&b.el&&c.getMonth()==a.getMonth()&&c.getFullYear()==a.getFullYear()){b.selectedUpdate(a,c)}else{b.fullUpdate(a,c)}b.innerEl.dom.title=Ext.String.format(b.ariaTitle,Ext.Date.format(b.activeDate,b.ariaTitleDateFormat))}return b},beforeDestroy:function(){var a=this;if(a.rendered){Ext.destroy(a.todayKeyListener,a.keyNav,a.monthPicker,a.monthBtn,a.nextRepeater,a.prevRepeater,a.todayBtn);delete a.textNodes;delete a.cells.elements}a.callParent()},onShow:function(){this.callParent(arguments);if(this.focusOnShow){this.focus()}}},function(){var b=this.prototype,a=Ext.Date;b.monthNames=a.monthNames;b.dayNames=a.dayNames;b.format=a.defaultFormat});Ext.define("Ext.form.field.Date",{extend:"Ext.form.field.Picker",alias:"widget.datefield",requires:["Ext.picker.Date"],alternateClassName:["Ext.form.DateField","Ext.form.Date"],format:"m/d/Y",altFormats:"m/d/Y|n/j/Y|n/j/y|m/j/y|n/d/y|m/j/Y|n/d/Y|m-d-y|m-d-Y|m/d|m-d|md|mdy|mdY|d|Y-m-d|n-j|n/j",disabledDaysText:"Disabled",disabledDatesText:"Disabled",minText:"The date in this field must be equal to or after {0}",maxText:"The date in this field must be equal to or before {0}",invalidText:"{0} is not a valid date - it must be in the format {1}",triggerCls:Ext.baseCSSPrefix+"form-date-trigger",showToday:true,useStrict:undefined,initTime:"12",initTimeFormat:"H",matchFieldWidth:false,startDay:0,initComponent:function(){var d=this,b=Ext.isString,c,a;c=d.minValue;a=d.maxValue;if(b(c)){d.minValue=d.parseDate(c)}if(b(a)){d.maxValue=d.parseDate(a)}d.disabledDatesRE=null;d.initDisabledDays();d.callParent()},initValue:function(){var a=this,b=a.value;if(Ext.isString(b)){a.value=a.rawToValue(b)}a.callParent()},initDisabledDays:function(){if(this.disabledDates){var b=this.disabledDates,a=b.length-1,g="(?:",h,e=b.length,c;for(h=0;h<e;h++){c=b[h];g+=Ext.isDate(c)?"^"+Ext.String.escapeRegex(c.dateFormat(this.format))+"$":c;if(h!==a){g+="|"}}this.disabledDatesRE=new RegExp(g+")")}},setDisabledDates:function(a){var c=this,b=c.picker;c.disabledDates=a;c.initDisabledDays();if(b){b.setDisabledDates(c.disabledDatesRE)}},setDisabledDays:function(a){var b=this.picker;this.disabledDays=a;if(b){b.setDisabledDays(a)}},setMinValue:function(c){var b=this,a=b.picker,d=(Ext.isString(c)?b.parseDate(c):c);b.minValue=d;if(a){a.minText=Ext.String.format(b.minText,b.formatDate(b.minValue));a.setMinDate(d)}},setMaxValue:function(c){var b=this,a=b.picker,d=(Ext.isString(c)?b.parseDate(c):c);b.maxValue=d;if(a){a.maxText=Ext.String.format(b.maxText,b.formatDate(b.maxValue));a.setMaxDate(d)}},getErrors:function(q){var j=this,p=Ext.String.format,k=Ext.Date.clearTime,o=j.callParent(arguments),n=j.disabledDays,d=j.disabledDatesRE,m=j.minValue,h=j.maxValue,g=n?n.length:0,e=0,a,b,l,c;q=j.formatDate(q||j.processRawValue(j.getRawValue()));if(q===null||q.length<1){return o}a=q;q=j.parseDate(q);if(!q){o.push(p(j.invalidText,a,Ext.Date.unescapeFormat(j.format)));return o}c=q.getTime();if(m&&c<k(m).getTime()){o.push(p(j.minText,j.formatDate(m)))}if(h&&c>k(h).getTime()){o.push(p(j.maxText,j.formatDate(h)))}if(n){l=q.getDay();for(;e<g;e++){if(l===n[e]){o.push(j.disabledDaysText);break}}}b=j.formatDate(q);if(d&&d.test(b)){o.push(p(j.disabledDatesText,b))}return o},rawToValue:function(a){return this.parseDate(a)||a||null},valueToRaw:function(a){return this.formatDate(this.parseDate(a))},safeParse:function(g,h){var e=this,c=Ext.Date,a=null,b=e.useStrict,d;if(c.formatContainsHourInfo(h)){a=c.parse(g,h,b)}else{d=c.parse(g+" "+e.initTime,h+" "+e.initTimeFormat,b);if(d){a=c.clearTime(d)}}return a},getSubmitValue:function(){var b=this.submitFormat||this.format,a=this.getValue();return a?Ext.Date.format(a,b):""},parseDate:function(e){if(!e||Ext.isDate(e)){return e}var d=this,h=d.safeParse(e,d.format),b=d.altFormats,g=d.altFormatsArray,c=0,a;if(!h&&b){g=g||b.split("|");a=g.length;for(;c<a&&!h;++c){h=d.safeParse(e,g[c])}}return h},formatDate:function(a){return Ext.isDate(a)?Ext.Date.dateFormat(a,this.format):a},createPicker:function(){var a=this,b=Ext.String.format;return new Ext.picker.Date({pickerField:a,ownerCt:a.ownerCt,renderTo:document.body,floating:true,hidden:true,focusOnShow:true,minDate:a.minValue,maxDate:a.maxValue,disabledDatesRE:a.disabledDatesRE,disabledDatesText:a.disabledDatesText,disabledDays:a.disabledDays,disabledDaysText:a.disabledDaysText,format:a.format,showToday:a.showToday,startDay:a.startDay,minText:b(a.minText,a.formatDate(a.minValue)),maxText:b(a.maxText,a.formatDate(a.maxValue)),listeners:{scope:a,select:a.onSelect},keyNavConfig:{esc:function(){a.collapse()}}})},onSelect:function(a,c){var b=this;b.setValue(c);b.fireEvent("select",b,c);b.collapse()},onExpand:function(){var a=this.getValue();this.picker.setValue(Ext.isDate(a)?a:new Date())},onCollapse:function(){this.focus(false,60)},beforeBlur:function(){var c=this,a=c.parseDate(c.getRawValue()),b=c.focusTask;if(b){b.cancel()}if(a){c.setValue(a)}}});Ext.define("Ext.form.field.File",{extend:"Ext.form.field.Trigger",alias:["widget.filefield","widget.fileuploadfield"],alternateClassName:["Ext.form.FileUploadField","Ext.ux.form.FileUploadField","Ext.form.File"],uses:["Ext.button.Button","Ext.layout.component.field.Field"],buttonText:"Browse...",buttonOnly:false,buttonMargin:3,fieldBodyCls:Ext.baseCSSPrefix+"form-file-wrap",readOnly:true,triggerNoEditCls:"",componentLayout:"triggerfield",childEls:["fileInputEl","buttonEl","buttonEl-btnEl","browseButtonWrap"],onRender:function(){var a=this,b;a.callParent(arguments);b=a.inputEl;b.dom.name="";a.fileInputEl.dom.name=a.getName();a.fileInputEl.on({scope:a,change:a.onFileChange});if(a.buttonOnly){a.inputCell.setDisplayed(false)}a.browseButtonWrap.dom.style.width=(a.browseButtonWrap.dom.lastChild.offsetWidth+a.buttonEl.getMargin("lr"))+"px";if(Ext.isIE){a.buttonEl.repaint()}},getTriggerMarkup:function(){var d=this,a,c=Ext.widget("button",Ext.apply({id:d.id+"-buttonEl",ui:d.ui,disabled:d.disabled,text:d.buttonText,cls:Ext.baseCSSPrefix+"form-file-btn",preventDefault:false,style:d.buttonOnly?"":"margin-left:"+d.buttonMargin+"px"},d.buttonConfig)),b=c.getRenderTree(),e={id:d.id+"-fileInputEl",cls:Ext.baseCSSPrefix+"form-file-input",tag:"input",type:"file",size:1};if(d.disabled){e.disabled=true}b.cn=e;a='<td id="'+d.id+'-browseButtonWrap">'+Ext.DomHelper.markup(b)+"</td>";c.destroy();return a},createFileInput:function(){var a=this;a.fileInputEl=a.buttonEl.createChild({name:a.getName(),id:a.id+"-fileInputEl",cls:Ext.baseCSSPrefix+"form-file-input",tag:"input",type:"file",size:1});a.fileInputEl.on({scope:a,change:a.onFileChange})},onFileChange:function(){this.lastValue=null;Ext.form.field.File.superclass.setValue.call(this,this.fileInputEl.dom.value)},setValue:Ext.emptyFn,reset:function(){var a=this;if(a.rendered){a.fileInputEl.remove();a.createFileInput();a.inputEl.dom.value=""}a.callParent()},onDisable:function(){this.callParent();this.disableItems()},disableItems:function(){var a=this.fileInputEl;if(a){a.dom.disabled=true}this["buttonEl-btnEl"].dom.disabled=true},onEnable:function(){var a=this;a.callParent();a.fileInputEl.dom.disabled=false;this["buttonEl-btnEl"].dom.disabled=false},isFileUpload:function(){return true},extractFileInput:function(){var a=this.fileInputEl.dom;this.reset();return a},onDestroy:function(){Ext.destroyMembers(this,"fileInputEl","buttonEl");this.callParent()}});Ext.define("Ext.form.field.Hidden",{extend:"Ext.form.field.Base",alias:["widget.hiddenfield","widget.hidden"],alternateClassName:"Ext.form.Hidden",inputType:"hidden",hideLabel:true,initComponent:function(){this.formItemCls+="-hidden";this.callParent()},isEqual:function(b,a){return this.isEqualAsString(b,a)},initEvents:Ext.emptyFn,setSize:Ext.emptyFn,setWidth:Ext.emptyFn,setHeight:Ext.emptyFn,setPosition:Ext.emptyFn,setPagePosition:Ext.emptyFn,markInvalid:Ext.emptyFn,clearInvalid:Ext.emptyFn});Ext.define("Ext.layout.component.field.HtmlEditor",{extend:"Ext.layout.component.field.Field",alias:["layout.htmleditor"],type:"htmleditor",toolbarSizePolicy:{setsWidth:0,setsHeight:0},beginLayout:function(a){this.callParent(arguments);a.textAreaContext=a.getEl("textareaEl");a.iframeContext=a.getEl("iframeEl");a.toolbarContext=a.context.getCmp(this.owner.getToolbar())},renderItems:Ext.emptyFn,getItemSizePolicy:function(a){return this.toolbarSizePolicy},getLayoutItems:function(){var a=this.owner.getToolbar();return a?[a]:[]},getRenderTarget:function(){return this.owner.bodyEl},publishInnerHeight:function(c,a){var b=this,d=a-b.measureLabelErrorHeight(c)-c.toolbarContext.getProp("height")-c.bodyCellContext.getPaddingInfo().height;if(Ext.isNumber(d)){c.textAreaContext.setHeight(d);c.iframeContext.setHeight(d)}else{b.done=false}}});Ext.define("Ext.picker.Color",{extend:"Ext.Component",requires:"Ext.XTemplate",alias:"widget.colorpicker",alternateClassName:"Ext.ColorPalette",componentCls:Ext.baseCSSPrefix+"color-picker",selectedCls:Ext.baseCSSPrefix+"color-picker-selected",value:null,clickEvent:"click",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"],colorRe:/(?:^|\s)color-(.{6})(?:\s|$)/,renderTpl:['<tpl for="colors">','<a href="#" class="color-{.}" hidefocus="on">','<em><span style="background:#{.}" unselectable="on">&#160;</span></em>',"</a>","</tpl>"],initComponent:function(){var a=this;a.callParent(arguments);a.addEvents("select");if(a.handler){a.on("select",a.handler,a.scope,true)}},initRenderData:function(){var a=this;return Ext.apply(a.callParent(),{itemCls:a.itemCls,colors:a.colors})},onRender:function(){var b=this,a=b.clickEvent;b.callParent(arguments);b.mon(b.el,a,b.handleClick,b,{delegate:"a"});if(a!="click"){b.mon(b.el,"click",Ext.emptyFn,b,{delegate:"a",stopEvent:true})}},afterRender:function(){var a=this,b;a.callParent(arguments);if(a.value){b=a.value;a.value=null;a.select(b,true)}},handleClick:function(c,d){var b=this,a;c.stopEvent();if(!b.disabled){a=d.className.match(b.colorRe)[1];b.select(a.toUpperCase())}},select:function(b,a){var d=this,g=d.selectedCls,e=d.value,c;b=b.replace("#","");if(!d.rendered){d.value=b;return}if(b!=e||d.allowReselect){c=d.el;if(d.value){c.down("a.color-"+e).removeCls(g)}c.down("a.color-"+b).addCls(g);d.value=b;if(a!==true){d.fireEvent("select",d,b)}}},getValue:function(){return this.value||null}});Ext.define("Ext.form.field.HtmlEditor",{extend:"Ext.Component",mixins:{labelable:"Ext.form.Labelable",field:"Ext.form.field.Field"},alias:"widget.htmleditor",alternateClassName:"Ext.form.HtmlEditor",requires:["Ext.tip.QuickTipManager","Ext.picker.Color","Ext.toolbar.Item","Ext.toolbar.Toolbar","Ext.util.Format","Ext.layout.component.field.HtmlEditor"],childEls:["iframeEl","textareaEl"],fieldSubTpl:["{beforeTextAreaTpl}",'<textarea id="{cmpId}-textareaEl" name="{name}" tabIndex="-1" {inputAttrTpl}',' class="{textareaCls}" style="{size}" autocomplete="off">',"{[Ext.util.Format.htmlEncode(values.value)]}","</textarea>","{afterTextAreaTpl}","{beforeIFrameTpl}",'<iframe id="{cmpId}-iframeEl" name="{iframeName}" frameBorder="0" {iframeAttrTpl}',' style="overflow:auto;{size}" src="{iframeSrc}"></iframe>',"{afterIFrameTpl}",{disableFormats:true}],subTplInsertions:["beforeTextAreaTpl","afterTextAreaTpl","beforeIFrameTpl","afterIFrameTpl","iframeAttrTpl","inputAttrTpl"],enableFormat:true,enableFontSize:true,enableColors:true,enableAlignments:true,enableLists:true,enableSourceEdit:true,enableLinks:true,enableFont:true,createLinkText:"Please enter the URL for the link:",defaultLinkValue:"http://",fontFamilies:["Arial","Courier New","Tahoma","Times New Roman","Verdana"],defaultFont:"tahoma",defaultValue:(Ext.isOpera||Ext.isIE6)?"&#160;":"&#8203;",editorWrapCls:Ext.baseCSSPrefix+"html-editor-wrap",componentLayout:"htmleditor",initialized:false,activated:false,sourceEditMode:false,iframePad:3,hideMode:"offsets",afterBodyEl:"</div>",maskOnDisable:true,initComponent:function(){var a=this;a.addEvents("initialize","activate","beforesync","beforepush","sync","push","editmodechange");a.callParent(arguments);a.createToolbar(a);a.initLabelable();a.initField()},getRefItems:function(){return[this.toolbar]},createToolbar:function(g){var j=this,h=[],c,l=Ext.tip.QuickTipManager&&Ext.tip.QuickTipManager.isEnabled(),e=Ext.baseCSSPrefix,d,k,b;function a(n,i,m){return{itemId:n,cls:e+"btn-icon",iconCls:e+"edit-"+n,enableToggle:i!==false,scope:g,handler:m||g.relayBtnCmd,clickEvent:"mousedown",tooltip:l?g.buttonTips[n]||b:b,overflowText:g.buttonTips[n].title||b,tabIndex:-1}}if(j.enableFont&&!Ext.isSafari2){d=Ext.widget("component",{renderTpl:['<select id="{id}-selectEl" class="{cls}">','<tpl for="fonts">','<option value="{[values.toLowerCase()]}" style="font-family:{.}"<tpl if="values.toLowerCase()==parent.defaultFont"> selected</tpl>>{.}</option>',"</tpl>","</select>"],renderData:{cls:e+"font-select",fonts:j.fontFamilies,defaultFont:j.defaultFont},childEls:["selectEl"],afterRender:function(){j.fontSelect=this.selectEl;Ext.Component.prototype.afterRender.apply(this,arguments)},onDisable:function(){var i=this.selectEl;if(i){i.dom.disabled=true}Ext.Component.prototype.onDisable.apply(this,arguments)},onEnable:function(){var i=this.selectEl;if(i){i.dom.disabled=false}Ext.Component.prototype.onEnable.apply(this,arguments)},listeners:{change:function(){j.relayCmd("fontname",j.fontSelect.dom.value);j.deferFocus()},element:"selectEl"}});h.push(d,"-")}if(j.enableFormat){h.push(a("bold"),a("italic"),a("underline"))}if(j.enableFontSize){h.push("-",a("increasefontsize",false,j.adjustFont),a("decreasefontsize",false,j.adjustFont))}if(j.enableColors){h.push("-",{itemId:"forecolor",cls:e+"btn-icon",iconCls:e+"edit-forecolor",overflowText:g.buttonTips.forecolor.title,tooltip:l?g.buttonTips.forecolor||b:b,tabIndex:-1,menu:Ext.widget("menu",{plain:true,items:[{xtype:"colorpicker",allowReselect:true,focus:Ext.emptyFn,value:"000000",plain:true,clickEvent:"mousedown",handler:function(m,i){j.execCmd("forecolor",Ext.isWebKit||Ext.isIE?"#"+i:i);j.deferFocus();this.up("menu").hide()}}]})},{itemId:"backcolor",cls:e+"btn-icon",iconCls:e+"edit-backcolor",overflowText:g.buttonTips.backcolor.title,tooltip:l?g.buttonTips.backcolor||b:b,tabIndex:-1,menu:Ext.widget("menu",{plain:true,items:[{xtype:"colorpicker",focus:Ext.emptyFn,value:"FFFFFF",plain:true,allowReselect:true,clickEvent:"mousedown",handler:function(m,i){if(Ext.isGecko){j.execCmd("useCSS",false);j.execCmd("hilitecolor",i);j.execCmd("useCSS",true);j.deferFocus()}else{j.execCmd(Ext.isOpera?"hilitecolor":"backcolor",Ext.isWebKit||Ext.isIE?"#"+i:i);j.deferFocus()}this.up("menu").hide()}}]})})}if(j.enableAlignments){h.push("-",a("justifyleft"),a("justifycenter"),a("justifyright"))}if(!Ext.isSafari2){if(j.enableLinks){h.push("-",a("createlink",false,j.createLink))}if(j.enableLists){h.push("-",a("insertorderedlist"),a("insertunorderedlist"))}if(j.enableSourceEdit){h.push("-",a("sourceedit",true,function(i){j.toggleSourceEdit(!j.sourceEditMode)}))}}for(c=0;c<h.length;c++){if(h[c].itemId!=="sourceedit"){h[c].disabled=true}}k=Ext.widget("toolbar",{id:j.id+"-toolbar",ownerCt:j,cls:Ext.baseCSSPrefix+"html-editor-tb",enableOverflow:true,items:h,ownerLayout:j.getComponentLayout(),listeners:{click:function(i){i.preventDefault()},element:"el"}});j.toolbar=k},getMaskTarget:function(){return this.bodyEl},setReadOnly:function(e){var d=this,c=d.textareaEl,b=d.iframeEl,a;d.readOnly=e;if(c){c.dom.readOnly=e}if(d.initialized){a=d.getEditorBody();if(Ext.isIE){b.setDisplayed(false);a.contentEditable=!e;b.setDisplayed(true)}else{d.setDesignMode(!e)}if(a){a.style.cursor=e?"default":"text"}d.disableItems(e)}},getDocMarkup:function(){var b=this,a=b.iframeEl.getHeight()-b.iframePad*2;return Ext.String.format('<html><head><style type="text/css">body{border:0;margin:0;padding:{0}px;height:{1}px;box-sizing: border-box; -moz-box-sizing: border-box; -webkit-box-sizing: border-box;cursor:text}</style></head><body></body></html>',b.iframePad,a)},getEditorBody:function(){var a=this.getDoc();return a.body||a.documentElement},getDoc:function(){return(!Ext.isIE&&this.iframeEl.dom.contentDocument)||this.getWin().document},getWin:function(){return Ext.isIE?this.iframeEl.dom.contentWindow:window.frames[this.iframeEl.dom.name]},finishRenderChildren:function(){this.callParent();this.toolbar.finishRender()},onRender:function(){var a=this;a.callParent(arguments);a.inputEl=a.iframeEl;a.monitorTask=Ext.TaskManager.start({run:a.checkDesignMode,scope:a,interval:100})},initRenderTpl:function(){var a=this;if(!a.hasOwnProperty("renderTpl")){a.renderTpl=a.getTpl("labelableRenderTpl")}return a.callParent()},initRenderData:function(){this.beforeSubTpl='<div class="'+this.editorWrapCls+'">'+Ext.DomHelper.markup(this.toolbar.getRenderTree());return Ext.applyIf(this.callParent(),this.getLabelableRenderData())},getSubTplData:function(){return{$comp:this,cmpId:this.id,id:this.getInputId(),textareaCls:Ext.baseCSSPrefix+"hidden",value:this.value,iframeName:Ext.id(),iframeSrc:Ext.SSL_SECURE_URL,size:"height:100px;width:100%"}},getSubTplMarkup:function(){return this.getTpl("fieldSubTpl").apply(this.getSubTplData())},initFrameDoc:function(){var b=this,c,a;Ext.TaskManager.stop(b.monitorTask);c=b.getDoc();b.win=b.getWin();c.open();c.write(b.getDocMarkup());c.close();a={run:function(){var d=b.getDoc();if(d.body||d.readyState==="complete"){Ext.TaskManager.stop(a);b.setDesignMode(true);Ext.defer(b.initEditor,10,b)}},interval:10,duration:10000,scope:b};Ext.TaskManager.start(a)},checkDesignMode:function(){var a=this,b=a.getDoc();if(b&&(!b.editorInitialized||a.getDesignMode()!=="on")){a.initFrameDoc()}},setDesignMode:function(c){var a=this,b=a.getDoc();if(b){if(a.readOnly){c=false}b.designMode=(/on|true/i).test(String(c).toLowerCase())?"on":"off"}},getDesignMode:function(){var a=this.getDoc();return !a?"":String(a.designMode).toLowerCase()},disableItems:function(d){var b=this.getToolbar().items.items,c,a=b.length,e;for(c=0;c<a;c++){e=b[c];if(e.getItemId()!=="sourceedit"){e.setDisabled(d)}}},toggleSourceEdit:function(b){var g=this,d=g.iframeEl,a=g.textareaEl,e=Ext.baseCSSPrefix+"hidden",c=g.getToolbar().getComponent("sourceedit");if(!Ext.isBoolean(b)){b=!g.sourceEditMode}g.sourceEditMode=b;if(c.pressed!==b){c.toggle(b)}if(b){g.disableItems(true);g.syncValue();d.addCls(e);a.removeCls(e);a.dom.removeAttribute("tabIndex");a.focus();g.inputEl=a}else{if(g.initialized){g.disableItems(g.readOnly)}g.pushValue();d.removeCls(e);a.addCls(e);a.dom.setAttribute("tabIndex",-1);g.deferFocus();g.inputEl=d}g.fireEvent("editmodechange",g,b);g.updateLayout()},createLink:function(){var a=prompt(this.createLinkText,this.defaultLinkValue);if(a&&a!=="http://"){this.relayCmd("createlink",a)}},clearInvalid:Ext.emptyFn,setValue:function(c){var b=this,a=b.textareaEl;b.mixins.field.setValue.call(b,c);if(c===null||c===undefined){c=""}if(a){a.dom.value=c}b.pushValue();return this},cleanHtml:function(a){a=String(a);if(Ext.isWebKit){a=a.replace(/\sclass="(?:Apple-style-span|khtml-block-placeholder)"/gi,"")}if(a.charCodeAt(0)===parseInt(this.defaultValue.replace(/\D/g,""),10)){a=a.substring(1)}return a},syncValue:function(){var e=this,b,g,d,a,c;if(e.initialized){b=e.getEditorBody();d=b.innerHTML;if(Ext.isWebKit){a=b.getAttribute("style");c=a.match(/text-align:(.*?);/i);if(c&&c[1]){d='<div style="'+c[0]+'">'+d+"</div>"}}d=e.cleanHtml(d);if(e.fireEvent("beforesync",e,d)!==false){if(e.textareaEl.dom.value!=d){e.textareaEl.dom.value=d;g=true}e.fireEvent("sync",e,d);if(g){e.checkChange()}}}},getValue:function(){var a=this,b;if(!a.sourceEditMode){a.syncValue()}b=a.rendered?a.textareaEl.dom.value:a.value;a.value=b;return b},pushValue:function(){var b=this,a;if(b.initialized){a=b.textareaEl.dom.value||"";if(!b.activated&&a.length<1){a=b.defaultValue}if(b.fireEvent("beforepush",b,a)!==false){b.getEditorBody().innerHTML=a;if(Ext.isGecko){b.setDesignMode(false);b.setDesignMode(true)}b.fireEvent("push",b,a)}}},deferFocus:function(){this.focus(false,true)},getFocusEl:function(){var a=this,b=a.win;return b&&!a.sourceEditMode?b:a.textareaEl},initEditor:function(){try{var g=this,d=g.getEditorBody(),b=g.textareaEl.getStyles("font-size","font-family","background-image","background-repeat","background-color","color"),i,c;b["background-attachment"]="fixed";d.bgProperties="fixed";Ext.DomHelper.applyStyles(d,b);i=g.getDoc();if(i){try{Ext.EventManager.removeAll(i)}catch(h){}}c=Ext.Function.bind(g.onEditorEvent,g);Ext.EventManager.on(i,{mousedown:c,dblclick:c,click:c,keyup:c,buffer:100});c=g.onRelayedEvent;Ext.EventManager.on(i,{mousedown:c,mousemove:c,mouseup:c,click:c,dblclick:c,scope:g});if(Ext.isGecko){Ext.EventManager.on(i,"keypress",g.applyCommand,g)}if(g.fixKeys){Ext.EventManager.on(i,"keydown",g.fixKeys,g)}Ext.EventManager.on(window,"unload",g.beforeDestroy,g);i.editorInitialized=true;g.initialized=true;g.pushValue();g.setReadOnly(g.readOnly);g.fireEvent("initialize",g)}catch(a){}},beforeDestroy:function(){var a=this,d=a.monitorTask,c,g;if(d){Ext.TaskManager.stop(d)}if(a.rendered){try{c=a.getDoc();if(c){Ext.EventManager.removeAll(Ext.fly(c));for(g in c){if(c.hasOwnProperty&&c.hasOwnProperty(g)){delete c[g]}}}}catch(b){}Ext.destroyMembers(a,"toolbar","iframeEl","textareaEl")}a.callParent()},onRelayedEvent:function(c){var b=this.iframeEl,d=b.getXY(),a=c.getXY();c.xy=[d[0]+a[0],d[1]+a[1]];c.injectEvent(b);c.xy=a},onFirstFocus:function(){var c=this,b,a;c.activated=true;c.disableItems(c.readOnly);if(Ext.isGecko){c.win.focus();b=c.win.getSelection();if(!b.focusNode||b.focusNode.nodeType!==3){a=b.getRangeAt(0);a.selectNodeContents(c.getEditorBody());a.collapse(true);c.deferFocus()}try{c.execCmd("useCSS",true);c.execCmd("styleWithCSS",false)}catch(d){}}c.fireEvent("activate",c)},adjustFont:function(d){var e=d.getItemId()==="increasefontsize"?1:-1,c=this.getDoc().queryCommandValue("FontSize")||"2",a=Ext.isString(c)&&c.indexOf("px")!==-1,b;c=parseInt(c,10);if(a){if(c<=10){c=1+e}else{if(c<=13){c=2+e}else{if(c<=16){c=3+e}else{if(c<=18){c=4+e}else{if(c<=24){c=5+e}else{c=6+e}}}}}c=Ext.Number.constrain(c,1,6)}else{b=Ext.isSafari;if(b){e*=2}c=Math.max(1,c+e)+(b?"px":0)}this.execCmd("FontSize",c)},onEditorEvent:function(a){this.updateToolbar()},updateToolbar:function(){var e=this,d,g,a,c;if(e.readOnly){return}if(!e.activated){e.onFirstFocus();return}d=e.getToolbar().items.map;g=e.getDoc();if(e.enableFont&&!Ext.isSafari2){a=(g.queryCommandValue("FontName")||e.defaultFont).toLowerCase();c=e.fontSelect.dom;if(a!==c.value){c.value=a}}function b(){for(var k=0,h=arguments.length,j;k<h;k++){j=arguments[k];d[j].toggle(g.queryCommandState(j))}}if(e.enableFormat){b("bold","italic","underline")}if(e.enableAlignments){b("justifyleft","justifycenter","justifyright")}if(!Ext.isSafari2&&e.enableLists){b("insertorderedlist","insertunorderedlist")}Ext.menu.Manager.hideAll();e.syncValue()},relayBtnCmd:function(a){this.relayCmd(a.getItemId())},relayCmd:function(b,a){Ext.defer(function(){var c=this;c.focus();c.execCmd(b,a);c.updateToolbar()},10,this)},execCmd:function(d,c){var b=this,e=b.getDoc(),a;e.execCommand(d,false,c===a?null:c);b.syncValue()},applyCommand:function(d){if(d.ctrlKey){var a=this,g=d.getCharCode(),b;if(g>0){g=String.fromCharCode(g);switch(g){case"b":b="bold";break;case"i":b="italic";break;case"u":b="underline";break}if(b){a.win.focus();a.execCmd(b);a.deferFocus();d.preventDefault()}}}},insertAtCursor:function(c){var b=this,a;if(b.activated){b.win.focus();if(Ext.isIE){a=b.getDoc().selection.createRange();if(a){a.pasteHTML(c);b.syncValue();b.deferFocus()}}else{b.execCmd("InsertHTML",c);b.deferFocus()}}},fixKeys:(function(){if(Ext.isIE){return function(h){var c=this,b=h.getKey(),g=c.getDoc(),i=c.readOnly,a,d;if(b===h.TAB){h.stopEvent();if(!i){a=g.selection.createRange();if(a){a.collapse(true);a.pasteHTML("&#160;&#160;&#160;&#160;");c.deferFocus()}}}else{if(b===h.ENTER){if(!i){a=g.selection.createRange();if(a){d=a.parentElement();if(!d||d.tagName.toLowerCase()!=="li"){h.stopEvent();a.pasteHTML("<br />");a.collapse(false);a.select()}}}}}}}if(Ext.isOpera){return function(b){var a=this;if(b.getKey()===b.TAB){b.stopEvent();if(!a.readOnly){a.win.focus();a.execCmd("InsertHTML","&#160;&#160;&#160;&#160;");a.deferFocus()}}}}if(Ext.isWebKit){return function(c){var b=this,a=c.getKey(),d=b.readOnly;if(a===c.TAB){c.stopEvent();if(!d){b.execCmd("InsertText","\t");b.deferFocus()}}else{if(a===c.ENTER){c.stopEvent();if(!d){b.execCmd("InsertHtml","<br /><br />");b.deferFocus()}}}}}return null}()),getToolbar:function(){return this.toolbar},buttonTips:{bold:{title:"Bold (Ctrl+B)",text:"Make the selected text bold.",cls:Ext.baseCSSPrefix+"html-editor-tip"},italic:{title:"Italic (Ctrl+I)",text:"Make the selected text italic.",cls:Ext.baseCSSPrefix+"html-editor-tip"},underline:{title:"Underline (Ctrl+U)",text:"Underline the selected text.",cls:Ext.baseCSSPrefix+"html-editor-tip"},increasefontsize:{title:"Grow Text",text:"Increase the font size.",cls:Ext.baseCSSPrefix+"html-editor-tip"},decreasefontsize:{title:"Shrink Text",text:"Decrease the font size.",cls:Ext.baseCSSPrefix+"html-editor-tip"},backcolor:{title:"Text Highlight Color",text:"Change the background color of the selected text.",cls:Ext.baseCSSPrefix+"html-editor-tip"},forecolor:{title:"Font Color",text:"Change the color of the selected text.",cls:Ext.baseCSSPrefix+"html-editor-tip"},justifyleft:{title:"Align Text Left",text:"Align text to the left.",cls:Ext.baseCSSPrefix+"html-editor-tip"},justifycenter:{title:"Center Text",text:"Center text in the editor.",cls:Ext.baseCSSPrefix+"html-editor-tip"},justifyright:{title:"Align Text Right",text:"Align text to the right.",cls:Ext.baseCSSPrefix+"html-editor-tip"},insertunorderedlist:{title:"Bullet List",text:"Start a bulleted list.",cls:Ext.baseCSSPrefix+"html-editor-tip"},insertorderedlist:{title:"Numbered List",text:"Start a numbered list.",cls:Ext.baseCSSPrefix+"html-editor-tip"},createlink:{title:"Hyperlink",text:"Make the selected text a hyperlink.",cls:Ext.baseCSSPrefix+"html-editor-tip"},sourceedit:{title:"Source Edit",text:"Switch to source editing mode.",cls:Ext.baseCSSPrefix+"html-editor-tip"}}});Ext.define("Ext.form.field.Radio",{extend:"Ext.form.field.Checkbox",alias:["widget.radiofield","widget.radio"],alternateClassName:"Ext.form.Radio",requires:["Ext.form.RadioManager"],isRadio:true,inputType:"radio",ariaRole:"radio",formId:null,getGroupValue:function(){var a=this.getManager().getChecked(this.name,this.getFormId());return a?a.inputValue:null},onBoxClick:function(b){var a=this;if(!a.disabled&&!a.readOnly){this.setValue(true)}},onRemoved:function(){this.callParent(arguments);this.formId=null},setValue:function(a){var b=this,c;if(Ext.isBoolean(a)){b.callParent(arguments)}else{c=b.getManager().getWithValue(b.name,a,b.getFormId()).getAt(0);if(c){c.setValue(true)}}return b},getSubmitValue:function(){return this.checked?this.inputValue:null},getModelData:function(){return this.getSubmitData()},onChange:function(c,a){var g=this,e,d,b,h;g.callParent(arguments);if(c){h=g.getManager().getByName(g.name,g.getFormId()).items;d=h.length;for(e=0;e<d;e++){b=h[e];if(b!==g){b.setValue(false)}}}},getManager:function(){return Ext.form.RadioManager}});Ext.define("Ext.picker.Time",{extend:"Ext.view.BoundList",alias:"widget.timepicker",requires:["Ext.data.Store","Ext.Date"],increment:15,format:"g:i A",displayField:"disp",initDate:[2008,0,1],componentCls:Ext.baseCSSPrefix+"timepicker",loadMask:false,initComponent:function(){var c=this,a=Ext.Date,b=a.clearTime,d=c.initDate;c.absMin=b(new Date(d[0],d[1],d[2]));c.absMax=a.add(b(new Date(d[0],d[1],d[2])),"mi",(24*60)-1);c.store=c.createStore();c.updateList();c.callParent()},setMinValue:function(a){this.minValue=a;this.updateList()},setMaxValue:function(a){this.maxValue=a;this.updateList()},normalizeDate:function(a){var b=this.initDate;a.setFullYear(b[0],b[1],b[2]);return a},updateList:function(){var c=this,b=c.normalizeDate(c.minValue||c.absMin),a=c.normalizeDate(c.maxValue||c.absMax);c.store.filterBy(function(d){var e=d.get("date");return e>=b&&e<=a})},createStore:function(){var d=this,c=Ext.Date,e=[],b=d.absMin,a=d.absMax;while(b<=a){e.push({disp:c.dateFormat(b,d.format),date:b});b=c.add(b,"mi",d.increment)}return new Ext.data.Store({fields:["disp","date"],data:e})}});Ext.define("Ext.form.field.Time",{extend:"Ext.form.field.ComboBox",alias:"widget.timefield",requires:["Ext.form.field.Date","Ext.picker.Time","Ext.view.BoundListKeyNav","Ext.Date"],alternateClassName:["Ext.form.TimeField","Ext.form.Time"],triggerCls:Ext.baseCSSPrefix+"form-time-trigger",minText:"The time in this field must be equal to or after {0}",maxText:"The time in this field must be equal to or before {0}",invalidText:"{0} is not a valid time",format:"g:i A",altFormats:"g:ia|g:iA|g:i a|g:i A|h:i|g:i|H:i|ga|ha|gA|h a|g a|g A|gi|hi|gia|hia|g|H|gi a|hi a|giA|hiA|gi A|hi A",increment:15,pickerMaxHeight:300,selectOnTab:true,snapToIncrement:false,initDate:"1/1/2008",initDateFormat:"j/n/Y",ignoreSelection:0,queryMode:"local",displayField:"disp",valueField:"date",initComponent:function(){var c=this,b=c.minValue,a=c.maxValue;if(b){c.setMinValue(b)}if(a){c.setMaxValue(a)}c.displayTpl=new Ext.XTemplate('<tpl for=".">{[typeof values === "string" ? values : this.formatDate(values["'+c.displayField+'"])]}<tpl if="xindex < xcount">'+c.delimiter+"</tpl></tpl>",{formatDate:Ext.Function.bind(c.formatDate,c)});this.callParent()},transformOriginalValue:function(a){if(Ext.isString(a)){return this.rawToValue(a)}return a},isEqual:function(b,a){return Ext.Date.isEqual(b,a)},setMinValue:function(c){var b=this,a=b.picker;b.setLimit(c,true);if(a){a.setMinValue(b.minValue)}},setMaxValue:function(c){var b=this,a=b.picker;b.setLimit(c,false);if(a){a.setMaxValue(b.maxValue)}},setLimit:function(b,g){var a=this,e,c;if(Ext.isString(b)){e=a.parseDate(b)}else{if(Ext.isDate(b)){e=b}}if(e){c=Ext.Date.clearTime(new Date(a.initDate));c.setHours(e.getHours(),e.getMinutes(),e.getSeconds(),e.getMilliseconds())}else{c=null}a[g?"minValue":"maxValue"]=c},rawToValue:function(a){return this.parseDate(a)||a||null},valueToRaw:function(a){return this.formatDate(this.parseDate(a))},getErrors:function(d){var b=this,g=Ext.String.format,h=b.callParent(arguments),c=b.minValue,e=b.maxValue,a;d=b.formatDate(d||b.processRawValue(b.getRawValue()));if(d===null||d.length<1){return h}a=b.parseDate(d);if(!a){h.push(g(b.invalidText,d,Ext.Date.unescapeFormat(b.format)));return h}if(c&&a<c){h.push(g(b.minText,b.formatDate(c)))}if(e&&a>e){h.push(g(b.maxText,b.formatDate(e)))}return h},formatDate:function(){return Ext.form.field.Date.prototype.formatDate.apply(this,arguments)},parseDate:function(e){var d=this,h=e,b=d.altFormats,g=d.altFormatsArray,c=0,a;if(e&&!Ext.isDate(e)){h=d.safeParse(e,d.format);if(!h&&b){g=g||b.split("|");a=g.length;for(;c<a&&!h;++c){h=d.safeParse(e,g[c])}}}if(h&&d.snapToIncrement){h=new Date(Ext.Number.snap(h.getTime(),d.increment*60*1000))}return h},safeParse:function(e,g){var d=this,b=Ext.Date,c,a=null;if(b.formatContainsDateInfo(g)){a=b.parse(e,g)}else{c=b.parse(d.initDate+" "+e,d.initDateFormat+" "+g);if(c){a=c}}return a},getSubmitValue:function(){var a=this,c=a.submitFormat||a.format,b=a.getValue();return b?Ext.Date.format(b,c):null},createPicker:function(){var b=this,a;b.listConfig=Ext.apply({xtype:"timepicker",selModel:{mode:"SINGLE"},cls:undefined,minValue:b.minValue,maxValue:b.maxValue,increment:b.increment,format:b.format,maxHeight:b.pickerMaxHeight},b.listConfig);a=b.callParent();b.store=a.store;return a},onItemClick:function(b,a){var d=this,c=b.getSelectionModel().getSelection();if(c.length>0){c=c[0];if(c&&Ext.Date.isEqual(a.get("date"),c.get("date"))){d.collapse()}}},onListSelectionChange:function(c,e){var b=this,a=e[0],d=a?a.get("date"):null;if(!b.ignoreSelection){b.skipSync=true;b.setValue(d);b.skipSync=false;b.fireEvent("select",b,d);b.picker.clearHighlight();b.collapse();b.inputEl.focus()}},syncSelection:function(){var j=this,h=j.picker,c,g,k,b,i,e,a;if(h&&!j.skipSync){h.clearHighlight();k=j.getValue();g=h.getSelectionModel();j.ignoreSelection++;if(k===null){g.deselectAll()}else{if(Ext.isDate(k)){b=h.store.data.items;e=b.length;for(i=0;i<e;i++){a=b[i];if(Ext.Date.isEqual(a.get("date"),k)){c=a;break}}g.select(c)}}j.ignoreSelection--}},postBlur:function(){var a=this;a.callParent(arguments);a.setRawValue(a.formatDate(a.getValue()))},setValue:function(){this.getPicker();this.callParent(arguments)},getValue:function(){return this.parseDate(this.callParent(arguments))}});Ext.define("Ext.grid.CellEditor",{extend:"Ext.Editor",constructor:function(a){a=Ext.apply({},a);if(a.field){a.field.monitorTab=false}this.callParent([a])},onShow:function(){var b=this,d=b.boundEl.first(),a,c;if(d){a=d.dom.lastChild;if(a&&a.nodeType===3){c=b.cellTextNode=d.dom.lastChild;b.cellTextValue=c.nodeValue;c.nodeValue="\u00a0"}}b.callParent(arguments)},onHide:function(){var a=this,b=a.boundEl.first();if(b&&a.cellTextNode){a.cellTextNode.nodeValue=a.cellTextValue;delete a.cellTextNode;delete a.cellTextValue}a.callParent(arguments)},afterRender:function(){var a=this,b=a.field;a.callParent(arguments);if(b.isXType("checkboxfield")){b.mon(b.inputEl,{mousedown:a.onCheckBoxMouseDown,click:a.onCheckBoxClick,scope:a})}},onCheckBoxMouseDown:function(){this.completeEdit=Ext.emptyFn},onCheckBoxClick:function(){delete this.completeEdit;this.field.focus(false,10)},realign:function(e){var k=this,h=k.boundEl,j=h.first(),c=j.dom.childNodes,g=c.length,d=Ext.Array.clone(k.offsets),l=k.field.inputEl,b,i,m,a;if(k.isForTree&&(g>1||(g===1&&c[0].nodeType!==3))){b=j.last();i=b.getOffsetsTo(j)[0]+b.getWidth();m=j.getWidth();a=m-i;if(!k.editingPlugin.grid.columnLines){a--}d[0]+=i;k.addCls(Ext.baseCSSPrefix+"grid-editor-on-text-node")}else{a=h.getWidth()-1}if(e===true){k.field.setWidth(a)}k.alignTo(h,k.alignment,d)},onEditorTab:function(b){var a=this.field;if(a.onEditorTab){a.onEditorTab(b)}},alignment:"tl-tl",hideEl:false,cls:Ext.baseCSSPrefix+"small-editor "+Ext.baseCSSPrefix+"grid-editor",shim:false,shadow:false});Ext.define("Ext.grid.ColumnComponentLayout",{extend:"Ext.layout.component.Auto",alias:"layout.columncomponent",type:"columncomponent",setWidthInDom:true,getContentHeight:function(a){return this.owner.isGroupHeader?a.getProp("contentHeight"):this.callParent(arguments)},calculateOwnerHeightFromContentHeight:function(c,b){var a=this.callParent(arguments);if(this.owner.isGroupHeader){a+=this.owner.titleEl.dom.offsetHeight}return a},getContentWidth:function(a){return this.owner.isGroupHeader?a.getProp("contentWidth"):this.callParent(arguments)},calculateOwnerWidthFromContentWidth:function(b,a){return a+b.getPaddingInfo().width}});Ext.define("Ext.grid.ColumnLayout",{extend:"Ext.layout.container.HBox",alias:"layout.gridcolumn",type:"gridcolumn",reserveOffset:false,firstHeaderCls:Ext.baseCSSPrefix+"column-header-first",lastHeaderCls:Ext.baseCSSPrefix+"column-header-last",initLayout:function(){this.grid=this.owner.up("[scrollerOwner]");this.callParent()},beginLayout:function(j){var h=this,e=h.grid,b=e.view,d=0,c=h.getVisibleItems(),a=c.length,g;j.gridContext=j.context.getCmp(h.grid);if(e.lockable){if(h.owner.up("tablepanel")===b.normalGrid){b=b.normalGrid.getView()}else{b=null}}h.callParent(arguments);for(;d<a;d++){g=c[d];g.removeCls([h.firstHeaderCls,h.lastHeaderCls]);g.el.setStyle({height:"auto"});g.titleEl.setStyle({height:"auto",paddingTop:""})}if(a>0){c[0].addCls(h.firstHeaderCls);c[a-1].addCls(h.lastHeaderCls)}if(!h.owner.isHeader&&Ext.getScrollbarSize().width&&!e.collapsed&&b&&b.table.dom&&(b.autoScroll||b.overflowY)){j.viewContext=j.context.getCmp(b)}},roundFlex:function(a){return Math.floor(a)},calculate:function(e){var d=this,c=e.viewContext,b,a;d.callParent(arguments);if(e.state.parallelDone){e.setProp("columnWidthsDone",true)}if(c&&!e.state.overflowAdjust.width&&!e.gridContext.heightModel.shrinkWrap){b=c.tableContext.getProp("height");a=c.getProp("height");if(isNaN(b+a)){d.done=false}else{if(b>=a){e.gridContext.invalidate({after:function(){e.state.overflowAdjust={width:Ext.getScrollbarSize().width,height:0}}})}}}},completeLayout:function(c){var j=this,b=j.owner,a=c.state,g=false,k=j.sizeModels.calculated,e,h,d,m,l;j.callParent(arguments);if(!a.flexesCalculated&&b.forceFit&&!b.isHeader){e=c.childItems;h=e.length;for(d=0;d<h;d++){m=e[d];l=m.target;if(l.width){l.flex=c.childItems[d].flex=l.width;delete l.width;m.widthModel=k;g=true}}if(g){j.cacheFlexes(c);c.invalidate({state:{flexesCalculated:true}})}}},finalizeLayout:function(){var g=this,e=0,d,b,h,a=g.owner,c=a.titleEl;d=g.getVisibleItems();b=d.length;h=a.el.getViewSize().height;if(c){h-=c.getHeight()}for(;e<b;e++){d[e].setPadding(h)}},publishInnerCtSize:function(e){var d=this,c=e.state.boxPlan.targetSize,b=e.peek("contentWidth"),a;if((b!=null)&&!d.owner.isHeader){c.width=b;a=d.owner.ownerCt.view;if(a.autoScroll||a.overflowY){c.width+=Ext.getScrollbarSize().width}}return d.callParent(arguments)}});Ext.define("Ext.grid.LockingView",{mixins:{observable:"Ext.util.Observable"},eventRelayRe:/^(beforeitem|beforecontainer|item|container|cell)/,constructor:function(c){var g=this,i=[],a=g.eventRelayRe,b=c.locked.getView(),h=c.normal.getView(),d,e;Ext.apply(g,{lockedView:b,normalView:h,lockedGrid:c.locked,normalGrid:c.normal,panel:c.panel});g.mixins.observable.constructor.call(g,c);d=b.events;for(e in d){if(d.hasOwnProperty(e)&&a.test(e)){i.push(e)}}g.relayEvents(b,i);g.relayEvents(h,i);h.on({scope:g,itemmouseleave:g.onItemMouseLeave,itemmouseenter:g.onItemMouseEnter});b.on({scope:g,itemmouseleave:g.onItemMouseLeave,itemmouseenter:g.onItemMouseEnter})},getGridColumns:function(){var a=this.lockedGrid.headerCt.getGridColumns();return a.concat(this.normalGrid.headerCt.getGridColumns())},getEl:function(a){return this.getViewForColumn(a).getEl()},getViewForColumn:function(b){var a=this.lockedView,c;a.headerCt.cascade(function(d){if(d===b){c=true;return false}});return c?a:this.normalView},onItemMouseEnter:function(c,b){var g=this,d=g.lockedView,a=g.normalView,e;if(c.trackOver){if(c!==d){a=d}e=a.getNode(b);a.highlightItem(e)}},onItemMouseLeave:function(c,b){var e=this,d=e.lockedView,a=e.normalView;if(c.trackOver){if(c!==d){a=d}a.clearHighlight()}},relayFn:function(c,b){b=b||[];var a=this.lockedView;a[c].apply(a,b||[]);a=this.normalView;a[c].apply(a,b||[])},getSelectionModel:function(){return this.panel.getSelectionModel()},getStore:function(){return this.panel.store},getNode:function(a){return this.normalView.getNode(a)},getCell:function(b,c){var a=this.getViewForColumn(c),d;d=a.getNode(b);return Ext.fly(d).down(c.getCellSelector())},getRecord:function(b){var a=this.lockedView.getRecord(b);if(!b){a=this.normalView.getRecord(b)}return a},addElListener:function(a,c,b){this.relayFn("addElListener",arguments)},refreshNode:function(){this.relayFn("refreshNode",arguments)},refresh:function(){this.relayFn("refresh",arguments)},bindStore:function(){this.relayFn("bindStore",arguments)},addRowCls:function(){this.relayFn("addRowCls",arguments)},removeRowCls:function(){this.relayFn("removeRowCls",arguments)}});Ext.define("Ext.view.TableLayout",{extend:"Ext.layout.component.Auto",alias:["layout.tableview"],type:"tableview",beginLayout:function(b){var a=this;a.callParent(arguments);if(a.owner.table.dom){b.tableContext=b.getEl(a.owner.table);b.headerContext=b.context.getCmp(a.headerCt)}},calculate:function(b){var a=this;a.callParent(arguments);if(b.tableContext){if(b.state.columnWidthsSynced){if(b.hasProp("columnWidthsFlushed")){b.tableContext.setHeight(b.tableContext.el.dom.offsetHeight,false)}else{a.done=false}}else{if(b.headerContext.hasProp("columnWidthsDone")){b.context.queueFlush(a);b.state.columnWidthsSynced=true}a.done=false}}},measureContentHeight:function(a){if(!a.headerContext||a.hasProp("columnWidthsFlushed")){return this.callParent(arguments)}},flush:function(){var j=this,e=j.ownerContext.context,d=j.headerCt.getGridColumns(),c=0,b=d.length,h=j.owner.el,a=0,g;e.currentLayout=j;for(c=0;c<b;c++){g=d[c].hidden?0:e.getCmp(d[c]).props.width;a+=g;h.select(j.getColumnSelector(d[c])).setWidth(g)}h.select("table."+Ext.baseCSSPrefix+"grid-table-resizer").setWidth(a);j.ownerContext.setProp("columnWidthsFlushed",true)},finishedLayout:function(){var a=this,b;a.callParent(arguments);if(Ext.isGecko){b=a.headerCt.getGridColumns()[0];if(b){b=a.owner.el.down(a.getColumnSelector(b));if(b){b.setStyle("display","none");b.dom.scrollWidth;b.setStyle("display","")}}}},getColumnSelector:function(a){return"th."+Ext.baseCSSPrefix+"grid-col-resizer-"+a.id}});Ext.define("Ext.view.Table",{extend:"Ext.view.View",alias:"widget.tableview",uses:["Ext.view.TableLayout","Ext.view.TableChunker","Ext.util.DelayedTask","Ext.util.MixedCollection"],componentLayout:"tableview",baseCls:Ext.baseCSSPrefix+"grid-view",itemSelector:"tr."+Ext.baseCSSPrefix+"grid-row",cellSelector:"td."+Ext.baseCSSPrefix+"grid-cell",rowSelector:"tr."+Ext.baseCSSPrefix+"grid-row",firstCls:Ext.baseCSSPrefix+"grid-cell-first",lastCls:Ext.baseCSSPrefix+"grid-cell-last",headerRowSelector:"tr."+Ext.baseCSSPrefix+"grid-header-row",selectedItemCls:Ext.baseCSSPrefix+"grid-row-selected",selectedCellCls:Ext.baseCSSPrefix+"grid-cell-selected",focusedItemCls:Ext.baseCSSPrefix+"grid-row-focused",overItemCls:Ext.baseCSSPrefix+"grid-row-over",altRowCls:Ext.baseCSSPrefix+"grid-row-alt",rowClsRe:new RegExp("(?:^|\\s*)"+Ext.baseCSSPrefix+"grid-row-(first|last|alt)(?:\\s+|$)","g"),cellRe:new RegExp(Ext.baseCSSPrefix+"grid-cell-([^\\s]+) ",""),trackOver:true,getRowClass:null,stripeRows:true,markDirty:true,initialTpl:"<div></div>",initComponent:function(){var b=this,a=b.scroll;b.table=new Ext.dom.Element.Fly();b.table.id=b.id+"gridTable";b.autoScroll=undefined;if(a===true||a==="both"){b.autoScroll=true}else{if(a==="horizontal"){b.overflowX="auto"}else{if(a==="vertical"){b.overflowY="auto"}}}b.selModel.view=b;b.headerCt.view=b;b.headerCt.markDirty=b.markDirty;b.initFeatures(b.grid);delete b.grid;b.tpl=b.getTpl("initialTpl");b.callParent()},moveColumn:function(a,p,d){var n=this,l=(d>1)?document.createDocumentFragment():undefined,c=p,q=n.getGridColumns().length,o=q-1,b=(n.firstCls||n.lastCls)&&(p===0||p==q||a===0||a==o),g,e,r,k,m,h;if(n.rendered){h=n.el.query(n.headerRowSelector);r=n.el.query(n.rowSelector);if(p>a&&l){c-=d}for(g=0,k=h.length;g<k;++g){m=h[g];if(l){for(e=0;e<d;e++){l.appendChild(m.cells[a])}m.insertBefore(l,m.cells[c]||null)}else{m.insertBefore(m.cells[a],m.cells[c]||null)}}for(g=0,k=r.length;g<k;g++){m=r[g];if(b){if(a===0){Ext.fly(m.cells[0]).removeCls(n.firstCls);Ext.fly(m.cells[1]).addCls(n.firstCls)}else{if(a===o){Ext.fly(m.cells[o]).removeCls(n.lastCls);Ext.fly(m.cells[o-1]).addCls(n.lastCls)}}if(p===0){Ext.fly(m.cells[0]).removeCls(n.firstCls);Ext.fly(m.cells[a]).addCls(n.firstCls)}else{if(p===q){Ext.fly(m.cells[o]).removeCls(n.lastCls);Ext.fly(m.cells[a]).addCls(n.lastCls)}}}if(l){for(e=0;e<d;e++){l.appendChild(m.cells[a])}m.insertBefore(l,m.cells[c]||null)}else{m.insertBefore(m.cells[a],m.cells[c]||null)}}n.setNewTemplate()}},scrollToTop:Ext.emptyFn,addElListener:function(a,c,b){this.mon(this,a,c,b,{element:"el"})},getGridColumns:function(){return this.headerCt.getGridColumns()},getHeaderAtIndex:function(a){return this.headerCt.getHeaderAtIndex(a)},getCell:function(a,b){var c=this.getNode(a);return Ext.fly(c).down(b.getCellSelector())},getFeature:function(b){var a=this.featuresMC;if(a){return a.get(b)}},initFeatures:function(d){var g=this,c,e,b,a;g.featuresMC=new Ext.util.MixedCollection();e=g.features=g.constructFeatures();a=e?e.length:0;for(c=0;c<a;c++){b=e[c];b.view=g;b.grid=d;g.featuresMC.add(b);b.init()}},constructFeatures:function(){var g=this,e=g.features,d,b,c=0,a;if(e){b=[];a=e.length;for(;c<a;c++){d=e[c];if(!d.isFeature){d=Ext.create("feature."+d.ftype,d)}b[c]=d}}return b},attachEventsForFeatures:function(){var b=this.features,c=b.length,a=0;for(;a<c;a++){if(b[a].isFeature){b[a].attachEvents()}}},afterRender:function(){var a=this;a.callParent();if(!a.enableTextSelection){a.el.unselectable()}a.attachEventsForFeatures()},onViewScroll:function(b,a){this.callParent(arguments);this.fireEvent("bodyscroll",b,a)},prepareData:function(b,h,d){var g=this,k=g.headerCt.prepareData(b,h,d,g,g.ownerCt),a=g.features,e=a.length,c=0,j;for(;c<e;c++){j=a[c];if(j.isFeature){Ext.apply(k,j.getAdditionalData(b,h,d,k,g))}}return k},collectData:function(d,q){var n=this,s=n.callParent(arguments),c=n.headerCt,p=c.getFullWidth(),b=n.features,l=b.length,a={rows:s,fullWidth:p},h=0,t,g=0,m,k,e,r;m=s.length;if(n.getRowClass){for(;g<m;g++){k={};e=s[g];r=e.rowCls||"";e.rowCls=this.getRowClass(d[g],g,k,n.store)+" "+r}}for(;h<l;h++){t=b[h];if(t.isFeature&&t.collectData&&!t.disabled){a=t.collectData(d,s,q,p,a);break}}return a},refreshSize:function(){var b=this,a;b.table.attach(b.el.child("table",true));if(!b.hasLoadingHeight){a=b.up("tablepanel");Ext.suspendLayouts();b.callParent();if(a&&Ext.getScrollbarSize().width&&(b.autoScroll||b.overflowY)){a.updateLayout()}Ext.resumeLayouts(true)}},setNewTemplate:function(){var b=this,a=b.headerCt.getColumnsForTpl(true);b.tpl=b.getTableChunker().getTableTpl({rowCount:b.store.getCount(),columns:a,features:b.features,enableTextSelection:b.enableTextSelection})},getTableChunker:function(){return this.chunker||Ext.view.TableChunker},addRowCls:function(b,a){var c=this.getNode(b);if(c){Ext.fly(c).addCls(a)}},removeRowCls:function(b,a){var c=this.getNode(b);if(c){Ext.fly(c).removeCls(a)}},onRowSelect:function(a){this.addRowCls(a,this.selectedItemCls)},onRowDeselect:function(b){var a=this;a.removeRowCls(b,a.selectedItemCls);a.removeRowCls(b,a.focusedItemCls)},onCellSelect:function(b){var a=this.getCellByPosition(b,true);if(a){Ext.fly(a).addCls(this.selectedCellCls)}},onCellDeselect:function(b){var a=this.getCellByPosition(b,true);if(a){Ext.fly(a).removeCls(this.selectedCellCls)}},onCellFocus:function(a){this.focusCell(a)},getCellByPosition:function(a,b){if(a){var c=this.getNode(a.row),d=this.headerCt.getHeaderAtIndex(a.column);if(d&&c){return Ext.fly(c).down(d.getCellSelector(),b)}}return false},onRowFocus:function(d,b,a){var c=this;if(b){c.addRowCls(d,c.focusedItemCls);if(!a){c.focusRow(d)}}else{c.removeRowCls(d,c.focusedItemCls)}},focusRow:function(b){var g=this,k=g.getNode(b),c=g.el,i=0,a=g.ownerCt,j,h,e,d;if(k&&c){h=c.getY();e=h+c.dom.clientHeight;j=Ext.fly(k).getRegion();if(j.top<h){i=j.top-h}else{if(j.bottom>e){i=j.bottom-e}}d=g.getRecord(k);b=g.store.indexOf(d);if(i){a.scrollByDeltaY(i)}g.fireEvent("rowfocus",d,k,b)}},focusCell:function(h){var j=this,k=j.getCellByPosition(h),b=j.el,d=0,e=0,c=b.getRegion(),a=j.ownerCt,i,g;c.bottom=c.top+b.dom.clientHeight;c.right=c.left+b.dom.clientWidth;if(k){i=k.getRegion();if(i.top<c.top){d=i.top-c.top}else{if(i.bottom>c.bottom){d=i.bottom-c.bottom}}if(i.left<c.left){e=i.left-c.left}else{if(i.right>c.right){e=i.right-c.right}}if(d){a.scrollByDeltaY(d)}if(e){a.scrollByDeltaX(e)}b.focus();j.fireEvent("cellfocus",g,k,h)}},scrollByDelta:function(c,b){b=b||"scrollTop";var a=this.el.dom;a[b]=(a[b]+=c)},onUpdate:function(g,e,k,p){var v=this,j,d,l,s,r,u,q,b,c,w,t,r,a,n,m,h,o=v.editingPlugin&&v.editingPlugin.editing;if(v.viewReady){j=v.store.indexOf(e);a=v.headerCt.getGridColumns();n=v.overItemCls;if(a.length&&j>-1){d=v.bufferRender([e],j)[0];q=v.all.item(j);if(q){b=q.dom;m=q.hasCls(n);if(b.mergeAttributes){b.mergeAttributes(d,true)}else{l=d.attributes;s=l.length;for(r=0;r<s;r++){u=l[r].name;if(u!=="id"){b.setAttribute(u,l[r].value)}}}if(m){q.addCls(n)}c=q.query(v.cellSelector);w=Ext.fly(d).query(v.cellSelector);t=w.length;h=c[0].parentNode;for(r=0;r<t;r++){if(v.shouldUpdateCell(a[r],p)){if(o){Ext.fly(c[r]).syncContent(w[r])}else{h.insertBefore(w[r],c[r]);h.removeChild(c[r])}}}}v.fireEvent("itemupdate",e,j,d)}}},shouldUpdateCell:function(b,a){if(b.hasCustomRenderer){return true}return !a||Ext.Array.contains(a,b.dataIndex)},refresh:function(){var a=this;a.setNewTemplate();a.callParent(arguments);a.doStripeRows(0);a.headerCt.setSortState()},clearViewEl:function(){this.callParent();delete this.table.dom},processItemEvent:function(b,m,j,d){var h=this,k=d.getTarget(h.cellSelector,m),i=k?k.cellIndex:-1,a=h.statics().EventMap,c=h.getSelectionModel(),g=d.type,l;if(g=="keydown"&&!k&&c.getCurrentPosition){k=h.getCellByPosition(c.getCurrentPosition());if(k){k=k.dom;i=k.cellIndex}}l=h.fireEvent("uievent",g,h,k,j,i,d,b,m);if(l===false||h.callParent(arguments)===false){return false}if(g=="mouseover"||g=="mouseout"){return true}if(!k){return true}return !((h["onBeforeCell"+a[g]](k,i,b,m,j,d)===false)||(h.fireEvent("beforecell"+g,h,k,i,b,m,j,d)===false)||(h["onCell"+a[g]](k,i,b,m,j,d)===false)||(h.fireEvent("cell"+g,h,k,i,b,m,j,d)===false))},processSpecialEvent:function(k){var n=this,b=n.statics().EventMap,d=n.features,m=d.length,o=k.type,g,p,h,j,c,l,a=n.ownerCt;n.callParent(arguments);if(o=="mouseover"||o=="mouseout"){return}for(g=0;g<m;g++){p=d[g];if(p.hasFeatureEvent){j=k.getTarget(p.eventSelector,n.getTargetEl());if(j){h=p.eventPrefix;c=p.getFireEventArgs("before"+h+o,n,j,k);l=p.getFireEventArgs(h+o,n,j,k);if((n.fireEvent.apply(n,c)===false)||(a.fireEvent.apply(a,c)===false)||(n.fireEvent.apply(n,l)===false)||(a.fireEvent.apply(a,l)===false)){return false}}}}return true},onCellMouseDown:Ext.emptyFn,onCellMouseUp:Ext.emptyFn,onCellClick:Ext.emptyFn,onCellDblClick:Ext.emptyFn,onCellContextMenu:Ext.emptyFn,onCellKeyDown:Ext.emptyFn,onBeforeCellMouseDown:Ext.emptyFn,onBeforeCellMouseUp:Ext.emptyFn,onBeforeCellClick:Ext.emptyFn,onBeforeCellDblClick:Ext.emptyFn,onBeforeCellContextMenu:Ext.emptyFn,onBeforeCellKeyDown:Ext.emptyFn,expandToFit:function(b){if(b){var a=this.getMaxContentWidth(b);delete b.flex;b.setWidth(a)}},getMaxContentWidth:function(h){var a=h.getCellInnerSelector(),c=this.el.query(a),d=0,g=c.length,e=h.el.dom.scrollWidth,b;for(;d<g;d++){b=c[d].scrollWidth;if(b>e){e=b}}return e},getPositionByEvent:function(g){var d=this,b=g.getTarget(d.cellSelector),c=g.getTarget(d.itemSelector),a=d.getRecord(c),h=d.getHeaderByCell(b);return d.getPosition(a,h)},getHeaderByCell:function(b){if(b){var a=b.className.match(this.cellRe);if(a&&a[1]){return Ext.getCmp(a[1])}}return false},walkCells:function(l,m,h,n,a,o){if(!l){return}var j=this,p=l.row,d=l.column,k=j.store.getCount(),g=j.getFirstVisibleColumnIndex(),b=j.getLastVisibleColumnIndex(),i={row:p,column:d},c=j.headerCt.getHeaderAtIndex(d);if(!c||c.hidden){return false}h=h||{};m=m.toLowerCase();switch(m){case"right":if(d===b){if(n||p===k-1){return false}if(!h.ctrlKey){i.row=p+1;i.column=g}}else{if(!h.ctrlKey){i.column=d+j.getRightGap(c)}else{i.column=b}}break;case"left":if(d===g){if(n||p===0){return false}if(!h.ctrlKey){i.row=p-1;i.column=b}}else{if(!h.ctrlKey){i.column=d+j.getLeftGap(c)}else{i.column=g}}break;case"up":if(p===0){return false}else{if(!h.ctrlKey){i.row=p-1}else{i.row=0}}break;case"down":if(p===k-1){return false}else{if(!h.ctrlKey){i.row=p+1}else{i.row=k-1}}break}if(a&&a.call(o||window,i)!==true){return false}else{return i}},getFirstVisibleColumnIndex:function(){var a=this.getHeaderCt().getVisibleGridColumns()[0];return a?a.getIndex():-1},getLastVisibleColumnIndex:function(){var b=this.getHeaderCt().getVisibleGridColumns(),a=b[b.length-1];return a.getIndex()},getHeaderCt:function(){return this.headerCt},getPosition:function(a,e){var d=this,b=d.store,c=d.headerCt.getGridColumns();return{row:b.indexOf(a),column:Ext.Array.indexOf(c,e)}},getRightGap:function(a){var g=this.getHeaderCt(),e=g.getGridColumns(),b=Ext.Array.indexOf(e,a),c=b+1,d;for(;c<=e.length;c++){if(!e[c].hidden){d=c;break}}return d-b},beforeDestroy:function(){if(this.rendered){this.el.removeAllListeners()}this.callParent(arguments)},getLeftGap:function(a){var g=this.getHeaderCt(),e=g.getGridColumns(),c=Ext.Array.indexOf(e,a),d=c-1,b;for(;d>=0;d--){if(!e[d].hidden){b=d;break}}return b-c},onAdd:function(c,a,b){this.callParent(arguments);this.doStripeRows(b)},onRemove:function(c,a,b){this.callParent(arguments);this.doStripeRows(b)},doStripeRows:function(b,a){var d=this,e,h,c,g;if(d.rendered&&d.stripeRows){e=d.getNodes(b,a);for(c=0,h=e.length;c<h;c++){g=e[c];g.className=g.className.replace(d.rowClsRe," ");b++;if(b%2===0){g.className+=(" "+d.altRowCls)}}}}});Ext.define("Ext.grid.Lockable",{requires:["Ext.grid.LockingView","Ext.view.Table"],syncRowHeight:true,headerCounter:0,scrollDelta:40,unlockText:"Unlock",lockText:"Lock",determineXTypeToCreate:function(){var c=this,g,d,b,e,a;if(c.subGridXType){g=c.subGridXType}else{d=this.getXTypes().split("/");b=d.length;e=d[b-1];a=d[b-2];if(a!=="tablepanel"){g=a}else{g=e}}return g},injectLockable:function(){this.lockable=true;this.hasView=true;var t=this,b=Ext.getScrollbarSize().width===0,d=t.store=Ext.StoreManager.lookup(t.store),c=t.determineXTypeToCreate(),j=t.getSelectionModel(),l,p,q,o,s,h,m,n,a,e,r,g,u,k;l=t.constructFeatures();t.cloneFeatures();p=t.constructFeatures();q=t.constructPlugins();t.clonePlugins();o=t.constructPlugins();delete t.features;delete t.plugins;for(m=0,n=(l?l.length:0);m<n;m++){l[m].lockingPartner=p[m];p[m].lockingPartner=l[m]}s=Ext.apply({xtype:c,store:d,scrollerOwner:false,enableAnimations:false,scroll:b?"vertical":false,selModel:j,border:false,cls:Ext.baseCSSPrefix+"grid-inner-locked",isLayoutRoot:function(){return false},features:l,plugins:q},t.lockedGridConfig);h=Ext.apply({xtype:c,store:d,scrollerOwner:false,enableAnimations:false,selModel:j,border:false,isLayoutRoot:function(){return false},features:p,plugins:o},t.normalGridConfig);t.addCls(Ext.baseCSSPrefix+"grid-locked");Ext.copyTo(h,t,t.bothCfgCopy);Ext.copyTo(s,t,t.bothCfgCopy);Ext.copyTo(h,t,t.normalCfgCopy);Ext.copyTo(s,t,t.lockedCfgCopy);for(m=0;m<t.normalCfgCopy.length;m++){delete t[t.normalCfgCopy[m]]}for(m=0;m<t.lockedCfgCopy.length;m++){delete t[t.lockedCfgCopy[m]]}t.addEvents("lockcolumn","unlockcolumn");t.addStateEvents(["lockcolumn","unlockcolumn"]);t.lockedHeights=[];t.normalHeights=[];a=t.processColumns(t.columns);s.width=a.lockedWidth+Ext.num(j.headerWidth,0);s.columns=a.locked;h.columns=a.normal;h.flex=1;s.viewConfig=t.lockedViewConfig||{};s.viewConfig.loadingUseMsg=false;h.viewConfig=t.normalViewConfig||{};Ext.applyIf(s.viewConfig,t.viewConfig);Ext.applyIf(h.viewConfig,t.viewConfig);t.lockedGrid=Ext.ComponentManager.create(s);g=t.lockedGrid.getView();h.viewConfig.lockingPartner=g;t.normalGrid=Ext.ComponentManager.create(h);u=t.normalGrid.getView();t.view=new Ext.grid.LockingView({locked:t.lockedGrid,normal:t.normalGrid,panel:t});k={scroll:{fn:t.onLockedViewScroll,element:"el",scope:t}};if(!b){k.mousewheel={fn:t.onLockedViewMouseWheel,element:"el",scope:t}}if(t.syncRowHeight){k.refresh=t.onLockedViewRefresh;k.itemupdate=t.onLockedViewItemUpdate;k.scope=t}g.on(k);k={scroll:{fn:t.onNormalViewScroll,element:"el",scope:t},refresh:t.syncRowHeight?t.onNormalViewRefresh:t.updateSpacer,scope:t};u.on(k);e=t.lockedGrid.headerCt;r=t.normalGrid.headerCt;e.lockedCt=true;e.lockableInjected=true;r.lockableInjected=true;e.on({columnshow:t.onLockedHeaderShow,columnhide:t.onLockedHeaderHide,columnmove:t.onLockedHeaderMove,sortchange:t.onLockedHeaderSortChange,columnresize:t.onLockedHeaderResize,scope:t});r.on({columnmove:t.onNormalHeaderMove,sortchange:t.onNormalHeaderSortChange,scope:t});t.modifyHeaderCt();t.items=[t.lockedGrid,t.normalGrid];t.relayHeaderCtEvents(e);t.relayHeaderCtEvents(r);t.layout={type:"hbox",align:"stretch"}},processColumns:function(g){var e=0,a=g.length,b=0,d=[],c=[],h;for(;e<a;++e){h=g[e];if(!h.isComponent){h=Ext.apply({},g[e])}h.processed=true;if(h.locked){if(!h.hidden){b+=h.width||Ext.grid.header.Container.prototype.defaultWidth}d.push(h)}else{c.push(h)}if(!h.headerId){h.headerId=(h.initialConfig||h).id||("L"+(++this.headerCounter))}}return{lockedWidth:b,locked:{items:d,itemId:"lockedHeaderCt",stretchMaxPartner:"^^>>#normalHeaderCt"},normal:{items:c,itemId:"normalHeaderCt",stretchMaxPartner:"^^>>#lockedHeaderCt"}}},onLockedViewMouseWheel:function(i){var d=this,h=-d.scrollDelta,a=h*i.getWheelDeltas().y,b=d.lockedGrid.getView().el.dom,c,g;if(b){c=b.scrollTop!==b.scrollHeight-b.clientHeight;g=b.scrollTop!==0}if((a<0&&g)||(a>0&&c)){i.stopEvent();d.scrolling=true;b.scrollTop+=a;d.normalGrid.getView().el.dom.scrollTop=b.scrollTop;d.scrolling=false;d.onNormalViewScroll()}},onLockedViewScroll:function(){var e=this,d=e.lockedGrid.getView(),c=e.normalGrid.getView(),a,b;if(!e.scrolling){e.scrolling=true;c.el.dom.scrollTop=d.el.dom.scrollTop;if(e.store.buffered){b=d.el.child("table",true);a=c.el.child("table",true);b.style.position="absolute"}e.scrolling=false}},onNormalViewScroll:function(){var e=this,d=e.lockedGrid.getView(),c=e.normalGrid.getView(),a,b;if(!e.scrolling){e.scrolling=true;d.el.dom.scrollTop=c.el.dom.scrollTop;if(e.store.buffered){b=d.el.child("table",true);a=c.el.child("table",true);b.style.position="absolute";b.style.top=a.style.top}e.scrolling=false}},onLockedHeaderMove:function(){if(this.syncRowHeight){this.onNormalViewRefresh()}},onNormalHeaderMove:function(){if(this.syncRowHeight){this.onLockedViewRefresh()}},updateSpacer:function(){var d=this,b=d.lockedGrid.getView().el,c=d.normalGrid.getView().el.dom,a=b.dom.id+"-spacer",e=(c.offsetHeight-c.clientHeight)+"px";d.spacerEl=Ext.getDom(a);if(d.spacerEl){d.spacerEl.style.height=e}else{Ext.core.DomHelper.append(b,{id:a,style:"height: "+e})}},onLockedViewRefresh:function(){if(this.normalGrid.headerCt.getGridColumns().length){var e=this,a=e.lockedGrid.getView(),c=a.el,g=c.query(a.getItemSelector()),d=g.length,b=0;e.lockedHeights=[];for(;b<d;b++){e.lockedHeights[b]=g[b].offsetHeight}e.syncRowHeights();e.updateSpacer()}},onNormalViewRefresh:function(){if(this.lockedGrid.headerCt.getGridColumns().length){var e=this,a=e.normalGrid.getView(),c=a.el,g=c.query(a.getItemSelector()),d=g.length,b=0;e.normalHeights=[];for(;b<d;b++){e.normalHeights[b]=g[b].offsetHeight}e.syncRowHeights();e.updateSpacer()}},onLockedViewItemUpdate:function(a,b,c){if(this.normalGrid.headerCt.getGridColumns().length){this.lockedHeights[b]=c.offsetHeight;this.syncRowHeights()}},onNormalViewItemUpdate:function(a,b,c){if(this.lockedGrid.headerCt.getGridColumns().length){this.normalHeights[b]=c.offsetHeight;this.syncRowHeights()}},syncRowHeights:function(){var j=this,a=j.lockedHeights,k=j.normalHeights,h=a.length,e=0,l,c,d,g,b;if(a.length&&k.length){l=j.lockedGrid.getView();c=j.normalGrid.getView();d=l.el.query(l.getItemSelector());g=c.el.query(c.getItemSelector());for(;e<h;e++){if(!isNaN(a[e])&&!isNaN(k[e])){if(a[e]>k[e]){Ext.fly(g[e]).setHeight(a[e])}else{if(a[e]<k[e]){Ext.fly(d[e]).setHeight(k[e])}}}}b=c.el.dom.scrollTop;c.el.dom.scrollTop=b;l.el.dom.scrollTop=b;j.lockedHeights=[];j.normalHeights=[]}},modifyHeaderCt:function(){var a=this;a.lockedGrid.headerCt.getMenuItems=a.getMenuItems(a.lockedGrid.headerCt.getMenuItems,true);a.normalGrid.headerCt.getMenuItems=a.getMenuItems(a.normalGrid.headerCt.getMenuItems,false)},onUnlockMenuClick:function(){this.unlock()},onLockMenuClick:function(){this.lock()},getMenuItems:function(g,c){var h=this,i=h.unlockText,a=h.lockText,j=Ext.baseCSSPrefix+"hmenu-unlock",b=Ext.baseCSSPrefix+"hmenu-lock",e=Ext.Function.bind(h.onUnlockMenuClick,h),d=Ext.Function.bind(h.onLockMenuClick,h);return function(){var k=g.call(this);k.push("-",{cls:j,text:i,handler:e,disabled:!c});k.push({cls:b,text:a,handler:d,disabled:c});return k}},lock:function(a,d){var c=this,e=c.normalGrid,h=c.lockedGrid,g=e.headerCt,b=h.headerCt;a=a||g.getMenu().activeHeader;if(a.flex){a.width=a.getWidth();delete a.flex}Ext.suspendLayouts();a.ownerCt.remove(a,false);a.locked=true;if(Ext.isDefined(d)){b.insert(d,a)}else{b.add(a)}c.syncLockedSection();Ext.resumeLayouts(true);c.updateSpacer();c.fireEvent("lockcolumn",c,a)},syncLockedSection:function(){var a=this;a.syncLockedWidth();a.lockedGrid.getView().refresh();a.normalGrid.getView().refresh()},syncLockedWidth:function(){var c=this,a=c.lockedGrid,b=a.headerCt.getFullWidth(true);Ext.suspendLayouts();if(b>0){a.setWidth(b);a.show()}else{a.hide()}Ext.resumeLayouts(true);return b>0},onLockedHeaderResize:function(){this.syncLockedWidth()},onLockedHeaderHide:function(){this.syncLockedWidth()},onLockedHeaderShow:function(){this.syncLockedWidth()},onLockedHeaderSortChange:function(b,c,a){if(a){this.normalGrid.headerCt.clearOtherSortStates(null,true)}},onNormalHeaderSortChange:function(b,c,a){if(a){this.lockedGrid.headerCt.clearOtherSortStates(null,true)}},unlock:function(a,e){var d=this,g=d.normalGrid,i=d.lockedGrid,h=g.headerCt,c=i.headerCt,b=false;if(!Ext.isDefined(e)){e=0}a=a||c.getMenu().activeHeader;Ext.suspendLayouts();a.ownerCt.remove(a,false);if(d.syncLockedWidth()){b=true}a.locked=false;h.insert(e,a);d.normalGrid.getView().refresh();if(b){d.lockedGrid.getView().refresh()}Ext.resumeLayouts(true);d.fireEvent("unlockcolumn",d,a)},applyColumnsState:function(h){var p=this,e=p.lockedGrid,g=e.headerCt,n=p.normalGrid.headerCt,q=Ext.Array.toMap(g.items,"headerId"),j=Ext.Array.toMap(n.items,"headerId"),m=[],o=[],l=1,b=h.length,k,a,d,c;for(k=0;k<b;k++){c=h[k];d=q[c.id];a=d||j[c.id];if(a){if(a.applyColumnState){a.applyColumnState(c)}if(a.locked===undefined){a.locked=!!d}if(a.locked){m.push(a);if(!a.hidden&&typeof a.width=="number"){l+=a.width}}else{o.push(a)}}}if(m.length+o.length==g.items.getCount()+n.items.getCount()){g.removeAll(false);n.removeAll(false);g.add(m);n.add(o);e.setWidth(l)}},getColumnsState:function(){var b=this,a=b.lockedGrid.headerCt.getColumnsState(),c=b.normalGrid.headerCt.getColumnsState();return a.concat(c)},reconfigureLockable:function(a,b){var c=this,e=c.lockedGrid,d=c.normalGrid;if(b){Ext.suspendLayouts();e.headerCt.removeAll();d.headerCt.removeAll();b=c.processColumns(b);e.setWidth(b.lockedWidth);e.headerCt.add(b.locked.items);d.headerCt.add(b.normal.items);Ext.resumeLayouts(true)}if(a){a=Ext.data.StoreManager.lookup(a);c.store=a;e.bindStore(a);d.bindStore(a)}else{e.getView().refresh();d.getView().refresh()}},cloneFeatures:function(){var e=this,d=e.features,c,b=0,a;if(d){a=d.length;for(;b<a;b++){c=d[b];if(c.isFeature){d[b]=c.clone()}}}},clonePlugins:function(){var e=this,b=e.plugins,d,c=0,a;if(b){a=b.length;for(;c<a;c++){d=b[c];if(typeof d.init==="function"){b[c]=d.clone()}}}}},function(){this.borrow(Ext.view.Table,["constructFeatures"]);this.borrow(Ext.AbstractComponent,["constructPlugins","constructPlugin"])});Ext.define("Ext.grid.PagingScroller",{percentageFromEdge:0.35,numFromEdge:2,trailingBufferZone:5,leadingBufferZone:15,scrollToLoadBuffer:200,viewSize:0,rowHeight:21,tableStart:0,tableEnd:0,constructor:function(a){var b=this;b.variableRowHeight=a.variableRowHeight;b.bindView(a.view);Ext.apply(b,a);b.callParent(arguments)},bindView:function(b){var g=this,d={scroll:{fn:g.onViewScroll,element:"el",scope:g},render:g.onViewRender,resize:g.onViewResize,boxready:{fn:g.onViewResize,scope:g,single:true},beforerefresh:g.beforeViewRefresh,refresh:g.onViewRefresh,scope:g},a={guaranteedrange:g.onGuaranteedRange,scope:g},c={reconfigure:g.onGridReconfigure,scope:g},e;if(g.view){if(g.view.el){g.view.el.un("scroll",g.onViewScroll,g)}e=b.lockingPartner;if(e){e.un("refresh",g.onLockRefresh,g)}g.view.un(d);g.store.un(a);if(g.grid){g.grid.un(c)}delete g.view.refreshSize}g.view=b;g.grid=g.view.up("tablepanel");g.store=b.store;if(b.rendered){g.viewSize=g.store.viewSize=Math.ceil(b.getHeight()/g.rowHeight)+g.trailingBufferZone+(g.numFromEdge*2)+g.leadingBufferZone}e=b.lockingPartner;if(e){e.on("refresh",g.onLockRefresh,g)}g.view.mon(g.store.pageMap,{scope:g,clear:g.onCacheClear});g.view.refreshSize=Ext.Function.createInterceptor(g.view.refreshSize,g.beforeViewrefreshSize,g);g.position=0;if(g.grid){g.grid.on(c)}else{g.view.on({added:function(){g.grid=g.view.up("tablepanel");g.grid.on(c)},single:true})}g.view.on(g.viewListeners=d);g.store.on(a)},onCacheClear:function(){var a=this;if(a.view.rendered&&!a.store.isDestroyed){a.ignoreNextScrollEvent=a.view.el.dom.scrollTop!==0;a.view.el.dom.scrollTop=0;delete a.lastScrollDirection;delete a.scrollOffset;delete a.scrollProportion}},onGridReconfigure:function(a){this.bindView(a.view)},onViewRender:function(){var d=this,a=d.view,c=d.view.el,b;d.stretcher=d.createStretcher(a);a=a.lockingPartner;if(a){b=d.stretcher;d.stretcher=new Ext.CompositeElement(b);d.stretcher.add(d.createStretcher(a))}},createStretcher:function(a){var b=a.el;b.setStyle("position","relative");return b.createChild({style:{position:"absolute",width:"1px",height:0,top:0,left:0}},b.dom.firstChild)},onViewResize:function(b,d,a){var e=this,c;c=Math.ceil(a/e.rowHeight)+e.trailingBufferZone+(e.numFromEdge*2)+e.leadingBufferZone;if(c>e.viewSize){e.viewSize=e.store.viewSize=c;e.handleViewScroll(e.lastScrollDirection||1)}},beforeViewRefresh:function(){var b=this,a=b.view,c,d;b.focusOnRefresh=Ext.Element.getActiveElement===a.el.dom;if(b.variableRowHeight){d=b.lastScrollDirection;b.commonRecordIndex=undefined;if(d&&(b.previousStart!==undefined)&&(b.scrollProportion===undefined)&&(c=a.getNodes()).length){if(d===1){if(b.tableStart<=b.previousEnd){b.commonRecordIndex=c.length-1}}else{if(d===-1){if(b.tableEnd>=b.previousStart){b.commonRecordIndex=0}}}b.scrollOffset=-a.el.getOffsetsTo(c[b.commonRecordIndex])[1];b.commonRecordIndex-=(b.tableStart-b.previousStart)}else{b.scrollOffset=undefined}}},onLockRefresh:function(a){a.table.dom.style.position="absolute"},onViewRefresh:function(){var d=this,g=d.store,c,e=d.view,j=e.el,k=j.dom,m,i,b,l=e.table.dom,h,a;if(d.focusOnRefresh){j.focus();d.focusOnRefresh=false}d.disabled=true;if(g.getCount()===g.getTotalCount()||(g.isFiltered()&&!g.remoteFilter)){d.stretcher.setHeight(0);d.position=k.scrollTop=0;d.setTablePosition("absolute");return}d.stretcher.setHeight(c=d.getScrollHeight());a=k.scrollTop;d.isScrollRefresh=(a>0);if(d.scrollProportion!==undefined){d.setTablePosition("absolute");d.setTableTop((d.scrollProportion?(c*d.scrollProportion)-(l.offsetHeight*d.scrollProportion):0)+"px")}else{d.setTablePosition("absolute");d.setTableTop((h=(d.tableStart||0)*d.rowHeight)+"px");if(d.scrollOffset){m=e.getNodes();i=-j.getOffsetsTo(m[d.commonRecordIndex])[1];b=i-d.scrollOffset;d.position=(k.scrollTop+=b)}else{if((h>a)||((h+l.offsetHeight)<a+k.clientHeight)){d.lastScrollDirection=-1;d.position=k.scrollTop=h}}}d.disabled=false},setTablePosition:function(a){this.setViewTableStyle(this.view,"position",a)},setTableTop:function(a){this.setViewTableStyle(this.view,"top",a)},setViewTableStyle:function(a,c,b){a.el.child("table",true).style[c]=b;a=a.lockingPartner;if(a){a.el.child("table",true).style[c]=b}},beforeViewrefreshSize:function(){if(this.isScrollRefresh){this.view.table.attach(this.view.el.child("table",true));return(this.isScrollRefresh=false)}},onGuaranteedRange:function(b,e,a){var c=this,d=c.store;if(b.length&&c.visibleStart<b[0].index){return}c.previousStart=c.tableStart;c.previousEnd=c.tableEnd;c.tableStart=e;c.tableEnd=a;d.loadRecords(b,{start:e})},onViewScroll:function(g,c){var d=this,a=d.view,b=d.position;d.position=a.el.dom.scrollTop;if(d.ignoreNextScrollEvent){d.ignoreNextScrollEvent=false;return}if(!d.disabled){d.lastScrollDirection=d.position>b?1:-1;if(b!==d.position){d.handleViewScroll(d.lastScrollDirection)}}},handleViewScroll:function(i){var e=this,k=e.store,h=e.view,g=e.viewSize,l=k.getTotalCount(),d=l-g,c=e.getFirstVisibleRowIndex(),j=e.getLastVisibleRowIndex(),a=h.el.dom,b,m;if(l>=g){e.scrollProportion=undefined;if(i==-1){if(e.tableStart){if(c!==undefined){if(c<(e.tableStart+e.numFromEdge)){b=Math.max(0,j+e.trailingBufferZone-g)}}else{e.scrollProportion=a.scrollTop/(a.scrollHeight-a.clientHeight);b=Math.max(0,l*e.scrollProportion-(g/2)-e.numFromEdge-((e.leadingBufferZone+e.trailingBufferZone)/2))}}}else{if(c!==undefined){if(j>(e.tableEnd-e.numFromEdge)){b=Math.max(0,c-e.trailingBufferZone)}}else{e.scrollProportion=a.scrollTop/(a.scrollHeight-a.clientHeight);b=l*e.scrollProportion-(g/2)-e.numFromEdge-((e.leadingBufferZone+e.trailingBufferZone)/2)}}if(b!==undefined){if(b>d){b=d&~1;m=l-1}else{b=b&~1;m=b+g-1}if(k.rangeCached(b,m)){e.cancelLoad();k.guaranteeRange(b,m)}else{e.attemptLoad(b,m)}}}},getFirstVisibleRowIndex:function(){var d=this,a=d.view,h=a.el.dom.scrollTop,e,c,b,g;if(d.variableRowHeight){e=a.getNodes();c=e.length;if(!c){return}g=Ext.fly(e[0]).getOffsetsTo(a.el)[1];for(b=0;b<c;b++){g+=e[b].offsetHeight;if(g>a.el.dom.clientHeight){return}if(g>0){return a.getRecord(e[b]).index}}}else{return Math.floor(h/d.rowHeight)}},getLastVisibleRowIndex:function(){var h=this,c=h.store,a=h.view,b=a.el.dom.clientHeight,j,g,e,d;if(h.variableRowHeight){j=a.getNodes();if(!j.length){return}g=c.getCount()-1;d=Ext.fly(j[g]).getOffsetsTo(a.el)[1]+j[g].offsetHeight;for(e=g;e>=0;e--){d-=j[e].offsetHeight;if(d<0){return}if(d<b){return a.getRecord(j[e]).index}}}else{return h.getFirstVisibleRowIndex()+Math.ceil(b/h.rowHeight)+1}},getScrollHeight:function(){var e=this,a=e.view,d,h,b=e.store,g=0,c=!e.hasOwnProperty("rowHeight");if(e.variableRowHeight){d=e.view.table.dom;if(c){e.initialTableHeight=d.offsetHeight;e.rowHeight=e.initialTableHeight/e.store.getCount()}else{g=d.offsetHeight-e.initialTableHeight;if(b.getCount()>e.viewSize){g-=e.rowHeight}}}else{if(c){h=a.el.down(a.getItemSelector());if(h){e.rowHeight=h.getHeight(false,true)}}}return Math.floor(b.getTotalCount()*e.rowHeight)+g},attemptLoad:function(c,a){var b=this;if(b.scrollToLoadBuffer){if(!b.loadTask){b.loadTask=new Ext.util.DelayedTask(b.doAttemptLoad,b,[])}b.loadTask.delay(b.scrollToLoadBuffer,b.doAttemptLoad,b,[c,a])}else{b.store.guaranteeRange(c,a)}},cancelLoad:function(){if(this.loadTask){this.loadTask.cancel()}},doAttemptLoad:function(b,a){this.store.guaranteeRange(b,a)},destroy:function(){var b=this,a=b.viewListeners.scroll;b.store.un({guaranteedrange:b.onGuaranteedRange,scope:b});b.view.un(b.viewListeners);if(b.view.rendered){b.stretcher.remove();b.view.el.un("scroll",a.fn,a.scope)}}});Ext.define("Ext.layout.container.Fit",{extend:"Ext.layout.container.Container",alternateClassName:"Ext.layout.FitLayout",alias:"layout.fit",itemCls:Ext.baseCSSPrefix+"fit-item",targetCls:Ext.baseCSSPrefix+"layout-fit",type:"fit",defaultMargins:{top:0,right:0,bottom:0,left:0},manageMargins:true,sizePolicies:{0:{setsWidth:0,setsHeight:0},1:{setsWidth:1,setsHeight:0},2:{setsWidth:0,setsHeight:1},3:{setsWidth:1,setsHeight:1}},getItemSizePolicy:function(b,c){var a=c||this.owner.getSizeModel(),d=(a.width.shrinkWrap?0:1)|(a.height.shrinkWrap?0:2);return this.sizePolicies[d]},beginLayoutCycle:function(k,g){var t=this,u=t.lastHeightModel&&t.lastHeightModel.calculated,h=t.lastWidthModel&&t.lastWidthModel.calculated,o=h||u,l=0,m=0,s,b,p,r,e,a,j,n,q,d;t.callParent(arguments);if(o&&k.targetContext.el.dom.tagName.toUpperCase()!="TD"){o=h=u=false}b=k.childItems;e=b.length;for(p=0;p<e;++p){r=b[p];if(g){s=r.target;j=s.minHeight;n=s.minWidth;if(n||j){a=r.marginInfo||r.getMarginInfo();j+=a.height;n+=a.height;if(l<j){l=j}if(m<n){m=n}}}if(o){q=r.el.dom.style;if(u){q.height=""}if(h){q.width=""}}}if(g){k.maxChildMinHeight=l;k.maxChildMinWidth=m}s=k.target;k.overflowX=(!k.widthModel.shrinkWrap&&k.maxChildMinWidth&&(s.autoScroll||s.overflowX))||d;k.overflowY=(!k.heightModel.shrinkWrap&&k.maxChildMinHeight&&(s.autoScroll||s.overflowY))||d},calculate:function(g){var o=this,l=g.childItems,d=l.length,c=o.getContainerSize(g),e={length:d,ownerContext:g,targetSize:c},r=g.widthModel.shrinkWrap,m=g.heightModel.shrinkWrap,k=g.overflowX,h=g.overflowY,n,b,p,j,a,q;if(k||h){n=o.getScrollbarsNeeded(k&&c.width,h&&c.height,g.maxChildMinWidth,g.maxChildMinHeight);if(n){b=Ext.getScrollbarSize();if(n&1){c.height-=b.height}if(n&2){c.width-=b.width}}}for(j=0;j<d;++j){e.index=j;o.fitItem(l[j],e)}if(m||r){p=g.targetContext.getPaddingInfo();if(r){if(h&&!c.gotHeight){o.done=false}else{a=e.contentWidth+p.width;if(n&2){a+=b.width}if(!g.setContentWidth(a)){o.done=false}}}if(m){if(k&&!c.gotWidth){o.done=false}else{q=e.contentHeight+p.height;if(n&1){q+=b.height}if(!g.setContentHeight(q)){o.done=false}}}}},fitItem:function(b,c){var a=this;if(b.invalid){a.done=false;return}c.margins=b.getMarginInfo();c.needed=c.got=0;a.fitItemWidth(b,c);a.fitItemHeight(b,c);if(c.got!=c.needed){a.done=false}},fitItemWidth:function(c,d){var a,b;if(d.ownerContext.widthModel.shrinkWrap){b=c.getProp("width")+d.margins.width;a=d.contentWidth;if(a===undefined){d.contentWidth=b}else{d.contentWidth=Math.max(a,b)}}else{if(c.widthModel.calculated){++d.needed;if(d.targetSize.gotWidth){++d.got;this.setItemWidth(c,d)}}}this.positionItemX(c,d)},fitItemHeight:function(c,d){var b,a;if(d.ownerContext.heightModel.shrinkWrap){a=c.getProp("height")+d.margins.height;b=d.contentHeight;if(b===undefined){d.contentHeight=a}else{d.contentHeight=Math.max(b,a)}}else{if(c.heightModel.calculated){++d.needed;if(d.targetSize.gotHeight){++d.got;this.setItemHeight(c,d)}}}this.positionItemY(c,d)},positionItemX:function(a,c){var b=c.margins;if(c.index||b.left){a.setProp("x",b.left)}if(b.width){a.setProp("margin-right",b.width)}},positionItemY:function(a,c){var b=c.margins;if(c.index||b.top){a.setProp("y",b.top)}if(b.height){a.setProp("margin-bottom",b.height)}},setItemHeight:function(a,b){a.setHeight(b.targetSize.height-b.margins.height)},setItemWidth:function(a,b){a.setWidth(b.targetSize.width-b.margins.width)}});Ext.define("Ext.panel.Table",{extend:"Ext.panel.Panel",alias:"widget.tablepanel",uses:["Ext.selection.RowModel","Ext.selection.CellModel","Ext.selection.CheckboxModel","Ext.grid.PagingScroller","Ext.grid.header.Container","Ext.grid.Lockable"],extraBaseCls:Ext.baseCSSPrefix+"grid",extraBodyCls:Ext.baseCSSPrefix+"grid-body",layout:"fit",hasView:false,viewType:null,selType:"rowmodel",scroll:true,deferRowRender:true,sortableColumns:true,enableLocking:false,scrollerOwner:true,enableColumnMove:true,sealedColumns:false,enableColumnResize:true,enableColumnHide:true,rowLines:true,initComponent:function(){var h=this,k=h.scroll,b=false,a=false,g=h.columns||h.colModel,j,c=h.border,d,e;if(h.columnLines){h.addCls(Ext.baseCSSPrefix+"grid-with-col-lines")}if(h.rowLines){h.addCls(Ext.baseCSSPrefix+"grid-with-row-lines")}h.store=Ext.data.StoreManager.lookup(h.store||"ext-empty-store");if(g instanceof Ext.grid.header.Container){h.headerCt=g;h.headerCt.border=c;h.columns=h.headerCt.items.items}else{if(Ext.isArray(g)){g={items:g,border:c}}Ext.apply(g,{forceFit:h.forceFit,sortable:h.sortableColumns,enableColumnMove:h.enableColumnMove,enableColumnResize:h.enableColumnResize,enableColumnHide:h.enableColumnHide,border:c,sealed:h.sealedColumns});h.columns=g.items;if(h.enableLocking||Ext.ComponentQuery.query("{locked !== undefined}{processed != true}",h.columns).length){h.self.mixin("lockable",Ext.grid.Lockable);h.injectLockable()}}h.scrollTask=new Ext.util.DelayedTask(h.syncHorizontalScroll,h);h.addEvents("reconfigure","viewready");h.bodyCls=h.bodyCls||"";h.bodyCls+=(" "+h.extraBodyCls);h.cls=h.cls||"";h.cls+=(" "+h.extraBaseCls);delete h.autoScroll;if(!h.hasView){if(!h.headerCt){h.headerCt=new Ext.grid.header.Container(g)}h.columns=h.headerCt.items.items;if(h.store.buffered&&!h.store.remoteSort){for(d=0,e=h.columns.length;d<e;d++){h.columns[d].sortable=false}}if(h.hideHeaders){h.headerCt.height=0;h.headerCt.addCls(Ext.baseCSSPrefix+"grid-header-ct-hidden");h.addCls(Ext.baseCSSPrefix+"grid-header-hidden");if(Ext.isIEQuirks){h.headerCt.style={display:"none"}}}if(k===true||k==="both"){b=a=true}else{if(k==="horizontal"){a=true}else{if(k==="vertical"){b=true}}}h.relayHeaderCtEvents(h.headerCt);h.features=h.features||[];if(!Ext.isArray(h.features)){h.features=[h.features]}h.dockedItems=[].concat(h.dockedItems||[]);h.dockedItems.unshift(h.headerCt);h.viewConfig=h.viewConfig||{};if(h.store&&h.store.buffered){h.viewConfig.preserveScrollOnRefresh=true}else{if(h.invalidateScrollerOnRefresh!==undefined){h.viewConfig.preserveScrollOnRefresh=!h.invalidateScrollerOnRefresh}}j=h.getView();h.items=[j];h.hasView=true;if(b){if(h.store.buffered){h.verticalScroller=new Ext.grid.PagingScroller(Ext.apply({panel:h,store:h.store,view:h.view},h.verticalScroller))}}if(a){if(!h.hideHeaders){j.on({scroll:{fn:h.onHorizontalScroll,element:"el",scope:h}})}}h.mon(j.store,{load:h.onStoreLoad,scope:h});h.mon(j,{viewready:h.onViewReady,refresh:h.onRestoreHorzScroll,scope:h})}this.relayEvents(h.view,["beforeitemmousedown","beforeitemmouseup","beforeitemmouseenter","beforeitemmouseleave","beforeitemclick","beforeitemdblclick","beforeitemcontextmenu","itemmousedown","itemmouseup","itemmouseenter","itemmouseleave","itemclick","itemdblclick","itemcontextmenu","beforecontainermousedown","beforecontainermouseup","beforecontainermouseover","beforecontainermouseout","beforecontainerclick","beforecontainerdblclick","beforecontainercontextmenu","containermouseup","containermouseover","containermouseout","containerclick","containerdblclick","containercontextmenu","selectionchange","beforeselect","select","beforedeselect","deselect"]);h.callParent(arguments);h.addStateEvents(["columnresize","columnmove","columnhide","columnshow","sortchange"]);if(h.headerCt){h.headerCt.on("afterlayout",h.onRestoreHorzScroll,h)}},relayHeaderCtEvents:function(a){this.relayEvents(a,["columnresize","columnmove","columnhide","columnshow","sortchange"])},getState:function(){var a=this,b=a.callParent(),c=a.store.sorters.first();b=a.addPropertyToState(b,"columns",(a.headerCt||a).getColumnsState());if(c){b=a.addPropertyToState(b,"sort",{property:c.property,direction:c.direction,root:c.root})}return b},applyState:function(d){var c=this,e=d.sort,a=c.store,b=d.columns;delete d.columns;c.callParent(arguments);if(b){(c.headerCt||c).applyColumnsState(b)}if(e){if(a.remoteSort){a.sort({property:e.property,direction:e.direction,root:e.root},null,false)}else{a.sort(e.property,e.direction)}}},getStore:function(){return this.store},getView:function(){var a=this,b;if(!a.view){b=a.getSelectionModel();a.view=Ext.widget(Ext.apply({},a.viewConfig,{grid:a,deferInitialRefresh:a.deferRowRender!==false,scroll:a.scroll,xtype:a.viewType,store:a.store,headerCt:a.headerCt,selModel:b,features:a.features,panel:a,emptyText:a.emptyText?'<div class="'+Ext.baseCSSPrefix+'grid-empty">'+a.emptyText+"</div>":""}));a.view.getComponentLayout().headerCt=a.headerCt;a.mon(a.view,{uievent:a.processEvent,scope:a});b.view=a.view;a.headerCt.view=a.view;a.relayEvents(a.view,["cellclick","celldblclick"])}return a.view},setAutoScroll:Ext.emptyFn,processEvent:function(g,b,a,c,d,i){var h=this,j;if(d!==-1){j=h.headerCt.getGridColumns()[d];return j.processEvent.apply(j,arguments)}},determineScrollbars:function(){},invalidateScroller:function(){},scrollByDeltaY:function(b,a){this.getView().scrollBy(0,b,a)},scrollByDeltaX:function(b,a){this.getView().scrollBy(b,0,a)},afterCollapse:function(){var a=this;a.saveScrollPos();a.saveScrollPos();a.callParent(arguments)},afterExpand:function(){var a=this;a.callParent(arguments);a.restoreScrollPos();a.restoreScrollPos()},saveScrollPos:Ext.emptyFn,restoreScrollPos:Ext.emptyFn,onHeaderResize:function(){this.delayScroll()},onHeaderMove:function(e,g,a,b,d){var c=this;if(c.optimizedColumnMove===false){c.view.refresh()}else{c.view.moveColumn(b,d,a)}c.delayScroll()},onHeaderHide:function(a,b){this.delayScroll()},onHeaderShow:function(a,b){this.delayScroll()},delayScroll:function(){var a=this.getScrollTarget().el;if(a){this.scrollTask.delay(10,null,null,[a.dom.scrollLeft])}},onViewReady:function(){this.fireEvent("viewready",this)},onRestoreHorzScroll:function(){var a=this.scrollLeftPos;if(a){this.syncHorizontalScroll(a,true)}},getScrollerOwner:function(){var a=this;if(!this.scrollerOwner){a=this.up("[scrollerOwner]")}return a},getLhsMarker:function(){var a=this;return a.lhsMarker||(a.lhsMarker=Ext.DomHelper.append(a.el,{cls:Ext.baseCSSPrefix+"grid-resize-marker"},true))},getRhsMarker:function(){var a=this;return a.rhsMarker||(a.rhsMarker=Ext.DomHelper.append(a.el,{cls:Ext.baseCSSPrefix+"grid-resize-marker"},true))},getSelectionModel:function(){if(!this.selModel){this.selModel={}}var b="SINGLE",a;if(this.simpleSelect){b="SIMPLE"}else{if(this.multiSelect){b="MULTI"}}Ext.applyIf(this.selModel,{allowDeselect:this.allowDeselect,mode:b});if(!this.selModel.events){a=this.selModel.selType||this.selType;this.selModel=Ext.create("selection."+a,this.selModel)}if(!this.selModel.hasRelaySetup){this.relayEvents(this.selModel,["selectionchange","beforeselect","beforedeselect","select","deselect"]);this.selModel.hasRelaySetup=true}if(this.disableSelection){this.selModel.locked=true}return this.selModel},getScrollTarget:function(){var a=this.getScrollerOwner(),b=a.query("tableview");return b[1]||b[0]},onHorizontalScroll:function(a,b){this.syncHorizontalScroll(b.scrollLeft)},syncHorizontalScroll:function(d,b){var c=this,a;b=b===true;if(c.rendered&&(b||d!==c.scrollLeftPos)){if(b){a=c.getScrollTarget();a.el.dom.scrollLeft=d}c.headerCt.el.dom.scrollLeft=d;c.scrollLeftPos=d}},onStoreLoad:Ext.emptyFn,getEditorParent:function(){return this.body},bindStore:function(a){var b=this;b.store=a;b.getView().bindStore(a)},beforeDestroy:function(){Ext.destroy(this.verticalScroller);this.callParent()},reconfigure:function(a,b){var c=this,d=c.headerCt;if(c.lockable){c.reconfigureLockable(a,b)}else{Ext.suspendLayouts();if(b){delete c.scrollLeftPos;d.removeAll();d.add(b)}if(a){a=Ext.StoreManager.lookup(a);c.bindStore(a)}else{c.getView().refresh()}d.setSortState();Ext.resumeLayouts(true)}c.fireEvent("reconfigure",c,a,b)}});Ext.define("Ext.grid.View",{extend:"Ext.view.Table",alias:"widget.gridview",stripeRows:true,autoScroll:true});Ext.define("Ext.grid.Panel",{extend:"Ext.panel.Table",requires:["Ext.grid.View"],alias:["widget.gridpanel","widget.grid"],alternateClassName:["Ext.list.ListView","Ext.ListView","Ext.grid.GridPanel"],viewType:"gridview",lockable:false,bothCfgCopy:["invalidateScrollerOnRefresh","hideHeaders","enableColumnHide","enableColumnMove","enableColumnResize","sortableColumns"],normalCfgCopy:["verticalScroller","verticalScrollDock","verticalScrollerType","scroll"],lockedCfgCopy:[],rowLines:true});Ext.define("Ext.grid.RowEditor",{extend:"Ext.form.Panel",requires:["Ext.tip.ToolTip","Ext.util.HashMap","Ext.util.KeyNav"],saveBtnText:"Update",cancelBtnText:"Cancel",errorsText:"Errors",dirtyText:"You need to commit or cancel your changes",lastScrollLeft:0,lastScrollTop:0,border:false,hideMode:"offsets",initComponent:function(){var b=this,a;b.cls=Ext.baseCSSPrefix+"grid-row-editor";b.layout={type:"hbox",align:"middle"};b.columns=new Ext.util.HashMap();b.columns.getKey=function(d){var c;if(d.getEditor){c=d.getEditor();if(c){return c.id}}return d.id};b.mon(b.columns,{add:b.onFieldAdd,remove:b.onFieldRemove,replace:b.onFieldReplace,scope:b});b.callParent(arguments);if(b.fields){b.setField(b.fields);delete b.fields}b.mon(Ext.container.Container.hierarchyEventSource,{scope:b,show:b.repositionIfVisible});a=b.getForm();a.trackResetOnLoad=true},onFieldChange:function(){var c=this,b=c.getForm(),a=b.isValid();if(c.errorSummary&&c.isVisible()){c[a?"hideToolTip":"showToolTip"]()}c.updateButton(a);c.isValid=a},updateButton:function(b){var a=this.floatingButtons;if(a){a.child("#update").setDisabled(!b)}},afterRender:function(){var b=this,a=b.editingPlugin;b.callParent(arguments);b.mon(b.renderTo,"scroll",b.onCtScroll,b,{buffer:100});b.mon(b.el,{click:Ext.emptyFn,stopPropagation:true});b.el.swallowEvent(["keypress","keydown"]);b.keyNav=new Ext.util.KeyNav(b.el,{enter:a.completeEdit,esc:a.onEscKey,scope:a});b.mon(a.view,{beforerefresh:b.onBeforeViewRefresh,refresh:b.onViewRefresh,itemremove:b.onViewItemRemove,scope:b})},onBeforeViewRefresh:function(b){var c=this,a=b.el.dom;if(c.el.dom.parentNode===a){a.removeChild(c.el.dom)}},onViewRefresh:function(c){var e=this,b=c.el.dom,d=e.context,a;b.appendChild(e.el.dom);if(d&&(a=d.store.indexOf(d.record))>=0){d.row=c.getNode(a);e.reposition();if(e.tooltip&&e.tooltip.isVisible()){e.tooltip.setTarget(d.row)}}else{e.editingPlugin.cancelEdit()}},onViewItemRemove:function(a,b){var c=this.context;if(c&&a===c.record){this.editingPlugin.cancelEdit()}},onCtScroll:function(d,c){var a=this,b=c.scrollTop,g=c.scrollLeft;if(b!==a.lastScrollTop){a.lastScrollTop=b;if((a.tooltip&&a.tooltip.isVisible())||a.hiddenTip){a.repositionTip()}}if(g!==a.lastScrollLeft){a.lastScrollLeft=g;a.reposition()}},onColumnAdd:function(a){if(!a.isGroupHeader){this.setField(a)}},onColumnRemove:function(a){this.columns.remove(a)},onColumnResize:function(b,a){if(!b.isGroupHeader){b.getEditor().setWidth(a-2);this.repositionIfVisible()}},onColumnHide:function(a){if(!a.isGroupHeader){a.getEditor().hide();this.repositionIfVisible()}},onColumnShow:function(a){var b=a.getEditor();b.setWidth(a.getWidth()-2).show();this.repositionIfVisible()},onColumnMove:function(b,a,c){if(!b.isGroupHeader){var d=b.getEditor();if(this.items.indexOf(d)!=c){this.move(a,c)}}},onFieldAdd:function(e,a,b){var c=this,g,d;if(!b.isGroupHeader){g=c.editingPlugin.grid.headerCt.getHeaderIndex(b);d=b.getEditor({xtype:"displayfield"});c.insert(g,d)}},onFieldRemove:function(g,a,b){var c=this,e,d;if(!b.isGroupHeader){e=b.getEditor();d=e.el;c.remove(e,false);if(d){d.remove()}}},onFieldReplace:function(d,a,c,b){this.onFieldRemove(d,a,b)},clearFields:function(){var b=this.columns,a;for(a in b){if(b.hasOwnProperty(a)){b.removeAtKey(a)}}},getFloatingButtons:function(){var e=this,g=Ext.baseCSSPrefix,d=g+"grid-row-editor-buttons",c=e.editingPlugin,a=Ext.panel.Panel.prototype.minButtonWidth,b;if(!e.floatingButtons){b=e.floatingButtons=new Ext.Container({renderTpl:['<div class="{baseCls}-ml"></div>','<div class="{baseCls}-mr"></div>','<div class="{baseCls}-bl"></div>','<div class="{baseCls}-br"></div>','<div class="{baseCls}-bc"></div>',"{%this.renderContainer(out,values)%}"],width:200,renderTo:e.el,baseCls:d,layout:{type:"hbox",align:"middle"},defaults:{flex:1,margins:"0 1 0 1"},items:[{itemId:"update",xtype:"button",handler:c.completeEdit,scope:c,text:e.saveBtnText,minWidth:a},{xtype:"button",handler:c.cancelEdit,scope:c,text:e.cancelBtnText,minWidth:a}]});e.mon(b.el,{mousedown:Ext.emptyFn,click:Ext.emptyFn,stopEvent:true})}return e.floatingButtons},repositionIfVisible:function(d){var b=this,a=b.view;if(d&&(d==b||!a.isDescendantOf(d))){return}if(b.isVisible()&&a.isVisible(true)){b.reposition()}},reposition:function(r){var s=this,c=s.context,e=c&&Ext.get(c.row),p=s.getFloatingButtons(),q=p.el,a=s.editingPlugin.grid,g=a.view.el,o=a.headerCt.getFullWidth(),t=a.getWidth(),l=Math.min(o,t),n=a.view.el.dom.scrollLeft,i=p.getWidth(),d=(l-i)/2+n,j,h,m,k=function(){q.scrollIntoView(g,false);if(r&&r.callback){r.callback.call(r.scope||s)}},b;if(e&&Ext.isElement(e.dom)){e.scrollIntoView(g,false);j=e.getXY()[1]-5;h=e.getHeight();m=h+(s.editingPlugin.grid.rowLines?9:10);if(s.getHeight()!=m){s.setHeight(m);s.el.setLeft(0)}if(r){b={to:{y:j},duration:r.duration||125,listeners:{afteranimate:function(){k();j=e.getXY()[1]-5}}};s.el.animate(b)}else{s.el.setY(j);k()}}if(s.getWidth()!=o){s.setWidth(o)}q.setLeft(d)},getEditor:function(a){var b=this;if(Ext.isNumber(a)){return b.query(">[isFormField]")[a]}else{if(a.isHeader&&!a.isGroupHeader){return a.getEditor()}}},removeField:function(b){var a=this;b=a.getEditor(b);a.mun(b,"validitychange",a.onValidityChange,a);a.columns.removeAtKey(b.id);Ext.destroy(b)},setField:function(b){var d=this,a,c,e;if(Ext.isArray(b)){c=b.length;for(a=0;a<c;a++){d.setField(b[a])}return}e=b.getEditor(null,{xtype:"displayfield",getModelData:function(){return null}});e.margins="0 0 0 2";d.mon(e,"change",d.onFieldChange,d);if(d.isVisible()&&d.context){if(e.is("displayfield")){d.renderColumnData(e,d.context.record,b)}else{e.suspendEvents();e.setValue(d.context.record.get(b.dataIndex));e.resumeEvents()}}d.columns.add(e.id,b);if(b.hidden){d.onColumnHide(b)}else{if(b.rendered){d.onColumnShow(b)}}},loadRecord:function(d){var j=this,a=j.getForm(),e=a.getFields(),h=e.items,b=h.length,c,g,k;for(c=0;c<b;c++){h[c].suspendEvents()}a.loadRecord(d);for(c=0;c<b;c++){h[c].resumeEvents()}k=a.isValid();if(j.errorSummary){if(k){j.hideToolTip()}else{j.showToolTip()}}j.updateButton(k);g=j.query(">displayfield");b=g.length;for(c=0;c<b;c++){j.renderColumnData(g[c],d)}},renderColumnData:function(m,i,c){var k=this,a=k.editingPlugin.grid,e=a.headerCt,l=a.view,o=l.store,g=c||k.columns.get(m.id),n=i.get(g.dataIndex),j=g.editRenderer||g.renderer,b,d,h;if(j){b={tdCls:"",style:""};d=o.indexOf(i);h=e.getHeaderIndex(g);n=j.call(g.scope||e.ownerCt,n,b,i,d,h,o,l)}m.setRawValue(n);m.resetOriginalValue()},beforeEdit:function(){var a=this;if(a.isVisible()&&a.errorSummary&&!a.autoCancel&&a.isDirty()){a.showToolTip();return false}},startEdit:function(a,g){var e=this,d=e.editingPlugin.grid,b=d.store,c=e.context=Ext.apply(e.editingPlugin.context,{view:d.getView(),store:b});c.grid.getSelectionModel().select(a);e.loadRecord(a);if(!e.isVisible()){e.show();e.focusContextCell()}else{e.reposition({callback:this.focusContextCell})}},focusContextCell:function(){var a=this.getEditor(this.context.colIdx);if(a&&a.focus){a.focus()}},cancelEdit:function(){var g=this,e=g.getForm(),a=e.getFields(),b=a.items,d=b.length,c;g.hide();e.clearInvalid();for(c=0;c<d;c++){b[c].suspendEvents()}e.reset();for(c=0;c<d;c++){b[c].resumeEvents()}},completeEdit:function(){var b=this,a=b.getForm();if(!a.isValid()){return}a.updateRecord(b.context.record);b.hide();return true},onShow:function(){this.callParent(arguments);this.reposition()},onHide:function(){var a=this;a.callParent(arguments);if(a.tooltip){a.hideToolTip()}if(a.context){a.context.view.focus();a.context=null}},isDirty:function(){var b=this,a=b.getForm();return a.isDirty()},getToolTip:function(){return this.tooltip||(this.tooltip=new Ext.tip.ToolTip({cls:Ext.baseCSSPrefix+"grid-row-editor-errors",title:this.errorsText,autoHide:false,closable:true,closeAction:"disable",anchor:"left"}))},hideToolTip:function(){var a=this,b=a.getToolTip();if(b.rendered){b.disable()}a.hiddenTip=false},showToolTip:function(){var c=this,d=c.getToolTip(),a=c.context,e=Ext.get(a.row),b=a.grid.view.el;d.setTarget(e);d.showAt([-10000,-10000]);d.update(c.getErrors());d.mouseOffset=[b.getWidth()-e.getWidth()+c.lastScrollLeft+15,0];c.repositionTip();d.doLayout();d.enable()},repositionTip:function(){var i=this,j=i.getToolTip(),c=i.context,l=Ext.get(c.row),k=c.grid.view.el,e=k.getHeight(),g=i.lastScrollTop,h=g+e,b=l.getHeight(),a=l.dom.offsetTop,d=a+b;if(d>g&&a<h){j.show();i.hiddenTip=false}else{j.hide();i.hiddenTip=true}},getErrors:function(){var d=this,e=!d.autoCancel&&d.isDirty()?d.dirtyText+"<br />":"",h=[],a=d.query(">[isFormField]"),c=a.length,b;function g(i){return"<li>"+i+"</li>"}for(b=0;b<c;b++){h=h.concat(Ext.Array.map(a[b].getErrors(),g))}return e+"<ul>"+h.join("")+"</ul>"},beforeDestroy:function(){Ext.destroy(this.floatingButtons,this.tooltip);this.callParent()}});Ext.define("Ext.grid.plugin.HeaderResizer",{extend:"Ext.AbstractPlugin",requires:["Ext.dd.DragTracker","Ext.util.Region"],alias:"plugin.gridheaderresizer",disabled:false,config:{dynamic:false},colHeaderCls:Ext.baseCSSPrefix+"column-header",minColWidth:40,maxColWidth:1000,wResizeCursor:"col-resize",eResizeCursor:"col-resize",init:function(a){this.headerCt=a;a.on("render",this.afterHeaderRender,this,{single:true})},destroy:function(){if(this.tracker){this.tracker.destroy()}},afterHeaderRender:function(){var b=this.headerCt,a=b.el;b.mon(a,"mousemove",this.onHeaderCtMouseMove,this);this.tracker=new Ext.dd.DragTracker({disabled:this.disabled,onBeforeStart:Ext.Function.bind(this.onBeforeStart,this),onStart:Ext.Function.bind(this.onStart,this),onDrag:Ext.Function.bind(this.onDrag,this),onEnd:Ext.Function.bind(this.onEnd,this),tolerance:3,autoStart:300,el:a})},onHeaderCtMouseMove:function(b,k){var d=this,a,i,j,g,c,h;if(d.headerCt.dragging){if(d.activeHd){d.activeHd.el.dom.style.cursor="";delete d.activeHd}}else{i=b.getTarget("."+d.colHeaderCls,3,true);if(i){j=Ext.getCmp(i.id);if(j.isOnLeftEdge(b)){g=j.previousNode("gridcolumn:not([hidden]):not([isGroupHeader])");if(g){h=d.headerCt.up("tablepanel");c=g.up("tablepanel");if(!((c===h)||((h.ownerCt.isXType("tablepanel"))&&h.ownerCt.view.lockedGrid===c))){g=null}}}else{if(j.isOnRightEdge(b)){g=j}else{g=null}}if(g){if(g.isGroupHeader){a=g.getGridColumns();g=a[a.length-1]}if(g&&!(g.fixed||(g.resizable===false)||d.disabled)){d.activeHd=g;j.el.dom.style.cursor=d.eResizeCursor}}else{j.el.dom.style.cursor="";delete d.activeHd}}}},onBeforeStart:function(b){var a=b.getTarget();this.dragHd=this.activeHd;if(!!this.dragHd&&!Ext.fly(a).hasCls(Ext.baseCSSPrefix+"column-header-trigger")&&!this.headerCt.dragging){this.tracker.constrainTo=this.getConstrainRegion();return true}else{this.headerCt.dragging=false;return false}},getConstrainRegion:function(){var c=this,a=c.dragHd.el,d=Ext.util.Region.getRegion(a),b;if(c.headerCt.forceFit){b=c.dragHd.nextNode("gridcolumn:not([hidden]):not([isGroupHeader])")}return d.adjust(0,c.headerCt.forceFit?(b?b.getWidth()-c.minColWidth:0):c.maxColWidth-a.getWidth(),0,c.minColWidth)},onStart:function(u){var v=this,h=v.dragHd,b=h.el,o=b.getWidth(),j=v.headerCt,l=u.getTarget(),d,r,g,k,c,n,a,i,s,q,p,m;if(v.dragHd&&!Ext.fly(l).hasCls(Ext.baseCSSPrefix+"column-header-trigger")){j.dragging=true}v.origWidth=o;if(!v.dynamic){d=b.getXY();r=j.up("[scrollerOwner]");g=v.dragHd.up(":not([isGroupHeader])");k=g.up();c=r.getLhsMarker();n=r.getRhsMarker();a=n.parent();i=a.getLocalX();s=a.getLocalY();q=a.translatePoints(d);p=k.body.getHeight()+j.getHeight();m=q.top-s;c.setTop(m);n.setTop(m);c.setHeight(p);n.setHeight(p);c.setLeft(q.left-i);n.setLeft(q.left+o-i)}},onDrag:function(h){if(!this.dynamic){var g=this.tracker.getXY("point"),a=this.headerCt.up("[scrollerOwner]"),i=a.getRhsMarker(),c=i.parent(),b=c.translatePoints(g),d=c.getLocalX();i.setLeft(b.left-d)}else{this.doResize()}},onEnd:function(g){this.headerCt.dragging=false;if(this.dragHd){if(!this.dynamic){var d=this.dragHd,b=this.headerCt.up("[scrollerOwner]"),c=b.getLhsMarker(),h=b.getRhsMarker(),a=-9999;c.setLeft(a);h.setLeft(a)}this.doResize()}},doResize:function(){if(this.dragHd){var b=this.dragHd,a,c=this.tracker.getOffset("point");if(b.flex){delete b.flex}Ext.suspendLayouts();b.setWidth(this.origWidth+c[0]);if(this.headerCt.forceFit){a=b.nextNode("gridcolumn:not([hidden]):not([isGroupHeader])");if(a){delete a.flex;a.setWidth(a.getWidth()-c[0])}}Ext.resumeLayouts(true)}},disable:function(){this.disabled=true;if(this.tracker){this.tracker.disable()}},enable:function(){this.disabled=false;if(this.tracker){this.tracker.enable()}}});Ext.define("Ext.grid.header.DragZone",{extend:"Ext.dd.DragZone",colHeaderCls:Ext.baseCSSPrefix+"column-header",maxProxyWidth:120,constructor:function(a){this.headerCt=a;this.ddGroup=this.getDDGroup();this.callParent([a.el]);this.proxy.el.addCls(Ext.baseCSSPrefix+"grid-col-dd")},getDDGroup:function(){return"header-dd-zone-"+this.headerCt.up("[scrollerOwner]").id},getDragData:function(b){var d=b.getTarget("."+this.colHeaderCls),a,c;if(d){a=Ext.getCmp(d.id);if(!this.headerCt.dragging&&a.draggable&&!(a.isOnLeftEdge(b)||a.isOnRightEdge(b))){c=document.createElement("div");c.innerHTML=Ext.getCmp(d.id).text;return{ddel:c,header:a}}}return false},onBeforeDrag:function(){return !(this.headerCt.dragging||this.disabled)},onInitDrag:function(){this.headerCt.dragging=true;this.callParent(arguments)},onDragDrop:function(){this.headerCt.dragging=false;this.callParent(arguments)},afterRepair:function(){this.callParent();this.headerCt.dragging=false},getRepairXY:function(){return this.dragData.header.el.getXY()},disable:function(){this.disabled=true},enable:function(){this.disabled=false}});Ext.define("Ext.grid.header.DropZone",{extend:"Ext.dd.DropZone",colHeaderCls:Ext.baseCSSPrefix+"column-header",proxyOffsets:[-4,-9],constructor:function(a){this.headerCt=a;this.ddGroup=this.getDDGroup();this.callParent([a.el])},getDDGroup:function(){return"header-dd-zone-"+this.headerCt.up("[scrollerOwner]").id},getTargetFromEvent:function(a){return a.getTarget("."+this.colHeaderCls)},getTopIndicator:function(){if(!this.topIndicator){this.topIndicator=Ext.DomHelper.append(Ext.getBody(),{cls:"col-move-top",html:"&#160;"},true)}return this.topIndicator},getBottomIndicator:function(){if(!this.bottomIndicator){this.bottomIndicator=Ext.DomHelper.append(Ext.getBody(),{cls:"col-move-bottom",html:"&#160;"},true)}return this.bottomIndicator},getLocation:function(d,b){var a=d.getXY()[0],c=Ext.fly(b).getRegion(),h,g;if((c.right-a)<=(c.right-c.left)/2){h="after"}else{h="before"}return{pos:h,header:Ext.getCmp(b.id),node:b}},positionIndicator:function(v,o,u){var a=this.getLocation(u,o),q=a.header,g=a.pos,d=v.nextSibling("gridcolumn:not([hidden])"),t=v.previousSibling("gridcolumn:not([hidden])"),l,r,s,b,c,k,m,x,w,n,j,p,h;if(!q.draggable&&q.getIndex()===0){return false}this.lastLocation=a;if((v!==q)&&((g==="before"&&d!==q)||(g==="after"&&t!==q))&&!q.isDescendantOf(v)){n=Ext.dd.DragDropManager.getRelated(this);j=n.length;p=0;for(;p<j;p++){h=n[p];if(h!==this&&h.invalidateDrop){h.invalidateDrop()}}this.valid=true;l=this.getTopIndicator();r=this.getBottomIndicator();if(g==="before"){s="tl";b="bl"}else{s="tr";b="br"}c=q.el.getAnchorXY(s);k=q.el.getAnchorXY(b);m=this.headerCt.el;x=m.getLeft();w=m.getRight();c[0]=Ext.Number.constrain(c[0],x,w);k[0]=Ext.Number.constrain(k[0],x,w);c[0]-=4;c[1]-=9;k[0]-=4;l.setXY(c);r.setXY(k);l.show();r.show()}else{this.invalidateDrop()}},invalidateDrop:function(){this.valid=false;this.hideIndicators()},onNodeOver:function(b,h,g,c){var i=this,d=i.headerCt,a=true,k=c.header,j;if(c.header.el.dom===b){a=false}else{j=i.getLocation(g,b).header;a=(k.ownerCt===j.ownerCt)||(!k.ownerCt.sealed&&!j.ownerCt.sealed)}if(a){i.positionIndicator(c.header,b,g)}else{i.valid=false}return i.valid?i.dropAllowed:i.dropNotAllowed},hideIndicators:function(){this.getTopIndicator().hide();this.getBottomIndicator().hide()},onNodeOut:function(){this.hideIndicators()},onNodeDrop:function(o,d,r,u){if(this.valid){var q=u.header,g=this.lastLocation,k=g.header,t=q.ownerCt,n=q.up("headercontainer:not(gridcolumn)"),l=t.items.indexOf(q),a=k.ownerCt,j=k.up("headercontainer:not(gridcolumn)"),p=a.items.indexOf(k),i=this.headerCt,b=i.getHeaderIndex(q),m=q.isGroupHeader?q.query(":not([isGroupHeader])").length:1,s=i.getHeaderIndex(k),c,h;if(g.pos==="after"){p++;s+=k.isGroupHeader?k.query(":not([isGroupHeader])").length:1}if(n!==j&&n.lockableInjected&&j.lockableInjected&&j.lockedCt){h=t.up("[scrollerOwner]");h.lock(q,p);this.onNodeDrop(o,d,r,u)}else{if(n!==j&&n.lockableInjected&&j.lockableInjected&&n.lockedCt){h=t.up("[scrollerOwner]");h.unlock(q,p);this.onNodeDrop(o,d,r,u)}else{this.invalidateDrop();if((t===a)&&(p>l)){p-=1}Ext.suspendLayouts();if(t!==a){t.remove(q,false);if(t.isGroupHeader){if(!t.items.getCount()){c=t.ownerCt;c.remove(t,false);t.el.dom.parentNode.removeChild(t.el.dom)}}}if(t===a){a.move(l,p)}else{a.insert(p,q)}if(a.isGroupHeader){if(a!==t){q.savedFlex=q.flex;delete q.flex;q.width=q.getWidth()}}else{if(q.savedFlex){q.flex=q.savedFlex;delete q.width}}i.purgeCache();Ext.resumeLayouts(true);i.onHeaderMoved(q,m,b,s);if(!t.items.getCount()){t.destroy()}}}}}});Ext.define("Ext.grid.plugin.HeaderReorderer",{extend:"Ext.AbstractPlugin",requires:["Ext.grid.header.DragZone","Ext.grid.header.DropZone"],alias:"plugin.gridheaderreorderer",init:function(a){this.headerCt=a;a.on({render:this.onHeaderCtRender,single:true,scope:this})},destroy:function(){Ext.destroy(this.dragZone,this.dropZone)},onHeaderCtRender:function(){var a=this;a.dragZone=new Ext.grid.header.DragZone(a.headerCt);a.dropZone=new Ext.grid.header.DropZone(a.headerCt);if(a.disabled){a.dragZone.disable()}},enable:function(){this.disabled=false;if(this.dragZone){this.dragZone.enable()}},disable:function(){this.disabled=true;if(this.dragZone){this.dragZone.disable()}}});Ext.define("Ext.grid.header.Container",{extend:"Ext.container.Container",requires:["Ext.grid.ColumnLayout","Ext.grid.plugin.HeaderResizer","Ext.grid.plugin.HeaderReorderer"],uses:["Ext.grid.column.Column","Ext.menu.Menu","Ext.menu.CheckItem","Ext.menu.Separator"],border:true,alias:"widget.headercontainer",baseCls:Ext.baseCSSPrefix+"grid-header-ct",dock:"top",weight:100,defaultType:"gridcolumn",detachOnRemove:false,defaultWidth:100,sortAscText:"Sort Ascending",sortDescText:"Sort Descending",sortClearText:"Clear Sort",columnsText:"Columns",headerOpenCls:Ext.baseCSSPrefix+"column-header-open",triStateSort:false,ddLock:false,dragging:false,sortable:true,initComponent:function(){var a=this;a.headerCounter=0;a.plugins=a.plugins||[];if(!a.isHeader){if(a.enableColumnResize){a.resizer=new Ext.grid.plugin.HeaderResizer();a.plugins.push(a.resizer)}if(a.enableColumnMove){a.reorderer=new Ext.grid.plugin.HeaderReorderer();a.plugins.push(a.reorderer)}}if(a.isHeader&&!a.items){a.layout=a.layout||"auto"}else{a.layout=Ext.apply({type:"gridcolumn",align:"stretchmax"},a.initialConfig.layout)}a.defaults=a.defaults||{};Ext.applyIf(a.defaults,{triStateSort:a.triStateSort,sortable:a.sortable});a.menuTask=new Ext.util.DelayedTask(a.updateMenuDisabledState,a);a.callParent();a.addEvents("columnresize","headerclick","headertriggerclick","columnmove","columnhide","columnshow","sortchange","menucreate")},onDestroy:function(){var a=this;a.menuTask.cancel();Ext.destroy(a.resizer,a.reorderer);a.callParent()},applyColumnsState:function(e){if(!e||!e.length){return}var m=this,k=m.items.items,j=k.length,g=0,b=e.length,l,d,a,h;for(l=0;l<b;l++){a=e[l];for(h=j;h--;){d=k[h];if(d.getStateId&&d.getStateId()==a.id){if(g!==h){m.moveHeader(h,g)}if(d.applyColumnState){d.applyColumnState(a)}++g;break}}}},getColumnsState:function(){var b=this,a=[],c;b.items.each(function(d){c=d.getColumnState&&d.getColumnState();if(c){a.push(c)}});return a},onAdd:function(d){var a=this,b=a.isHeader?a.getOwnerHeaderCt():a;if(!d.headerId){d.headerId=d.initialConfig.id||Ext.id(null,"header-")}if(!d.stateId){d.stateId=d.initialConfig.id||("h"+(++a.headerCounter))}a.callParent(arguments);if(b){b.purgeCache()}},onRemove:function(d){var a=this,b=a.isHeader?a.getOwnerHeaderCt():a;a.callParent(arguments);if(b){a.purgeCache()}},applyDefaults:function(b){var a;if(b&&!b.isComponent&&b.xtype=="rownumberer"){a=b}else{a=this.callParent(arguments);if(!b.isGroupHeader&&!("width" in a)&&!a.flex){a.width=this.defaultWidth}}return a},afterRender:function(){this.callParent();this.setSortState()},setSortState:function(){var a=this.up("[store]").store,c=a.getFirstSorter(),b;if(c){b=this.down("gridcolumn[dataIndex="+c.property+"]");if(b){b.setSortState(c.direction,false,true)}}else{this.clearOtherSortStates(null)}},getHeaderMenu:function(){var b=this.getMenu(),a;if(b){a=b.child("#columnItem");if(a){return a.menu}}return null},onHeaderVisibilityChange:function(e,d){var b=this,c=b.getHeaderMenu(),a;if(c){a=b.getMenuItemForHeader(c,e);if(a){a.setChecked(d,true)}b.menuTask.delay(50)}},getLeafMenuItems:function(){var h=this,d=h.getGridColumns(),b=[],c=0,g=0,a=d.length,j=h.getMenu(),e;for(;c<a;++c){e=d[c];if(e.hideable){e=h.getMenuItemForHeader(j,e);if(e){b.push(e);if(e.checked){++g}}}else{if(!e.hidden&&!e.menuDisabled){++g}}}return{items:b,checkedCount:g}},updateMenuDisabledState:function(){var h=this,b=h.getLeafMenuItems(),g=b.checkedCount,d=b.items,a=d.length,e=0,c=h.getMenu().child("#columnItem");if(g<=1){h.disableMenuItems(c,Ext.ComponentQuery.query("[checked=true]",d)[0])}else{for(;e<a;++e){h.setMenuItemState(g,c,d[e])}}},disableMenuItems:function(a,b){while(b&&b!=a){b.disableCheckChange();b=b.parentMenu.ownerItem}},setMenuItemState:function(e,a,d){var c,b;while(d&&d!=a){c=d.parentMenu;b=d.parentMenu.query("[checked=true]:not([menu])").length;d.enableCheckChange();d=c.ownerItem;if(b===e){break}}this.disableMenuItems(a,d)},getMenuItemForHeader:function(a,b){return b?a.down("menucheckitem[headerId="+b.id+"]"):null},onHeaderShow:function(c){var b=this,a=b.ownerCt;b.onHeaderVisibilityChange(c,true);if(!c.isGroupHeader){if(a){a.onHeaderShow(b,c)}}b.fireEvent("columnshow",b,c)},onHeaderHide:function(c){var b=this,a=b.ownerCt;b.onHeaderVisibilityChange(c,false);if(!c.isGroupHeader){if(a){a.onHeaderHide(b,c)}}b.fireEvent("columnhide",b,c)},tempLock:function(){this.ddLock=true;Ext.Function.defer(function(){this.ddLock=false},200,this)},onHeaderResize:function(g,b,e){var d=this,a=d.view,c=d.ownerCt;if(a&&a.table.dom){d.tempLock();if(c){c.onHeaderResize(d,g,b)}}d.fireEvent("columnresize",this,g,b)},onHeaderClick:function(c,b,a){c.fireEvent("headerclick",this,c,b,a);this.fireEvent("headerclick",this,c,b,a)},onHeaderTriggerClick:function(d,c,a){var b=this;if(d.fireEvent("headertriggerclick",b,d,c,a)!==false&&b.fireEvent("headertriggerclick",b,d,c,a)!==false){b.showMenuBy(a,d)}},showMenuBy:function(b,g){var d=this.getMenu(),e=d.down("#ascItem"),c=d.down("#descItem"),a;d.activeHeader=d.ownerCt=g;d.setFloatParent(g);g.titleEl.addCls(this.headerOpenCls);a=g.sortable?"enable":"disable";if(e){e[a]()}if(c){c[a]()}d.showBy(b)},onMenuDeactivate:function(){var a=this.getMenu();a.activeHeader.titleEl.removeCls(this.headerOpenCls)},moveHeader:function(a,b){this.tempLock();this.onHeaderMoved(this.move(a,b),1,a,b)},purgeCache:function(){var a=this;delete a.gridDataColumns;delete a.hideableColumns;if(a.menu){a.menu.hide();a.menu.destroy();delete a.menu}},onHeaderMoved:function(g,a,c,e){var d=this,b=d.ownerCt;if(b&&b.onHeaderMove){b.onHeaderMove(d,g,a,c,e)}d.fireEvent("columnmove",d,g,c,e)},getMenu:function(){var a=this;if(!a.menu){a.menu=new Ext.menu.Menu({hideOnParentHide:false,items:a.getMenuItems(),listeners:{deactivate:a.onMenuDeactivate,scope:a}});a.updateMenuDisabledState();a.fireEvent("menucreate",a,a.menu)}return a.menu},getMenuItems:function(){var c=this,b=[],a=c.enableColumnHide?c.getColumnMenu(c):null;if(c.sortable){b=[{itemId:"ascItem",text:c.sortAscText,cls:Ext.baseCSSPrefix+"hmenu-sort-asc",handler:c.onSortAscClick,scope:c},{itemId:"descItem",text:c.sortDescText,cls:Ext.baseCSSPrefix+"hmenu-sort-desc",handler:c.onSortDescClick,scope:c}]}if(a&&a.length){b.push("-",{itemId:"columnItem",text:c.columnsText,cls:Ext.baseCSSPrefix+"cols-icon",menu:a})}return b},onSortAscClick:function(){var b=this.getMenu(),a=b.activeHeader;a.setSortState("ASC")},onSortDescClick:function(){var b=this.getMenu(),a=b.activeHeader;a.setSortState("DESC")},getColumnMenu:function(g){var c=[],b=0,e,a=g.query(">gridcolumn[hideable]"),h=a.length,d;for(;b<h;b++){e=a[b];d=new Ext.menu.CheckItem({text:e.menuText||e.text,checked:!e.hidden,hideOnClick:false,headerId:e.id,menu:e.isGroupHeader?this.getColumnMenu(e):undefined,checkHandler:this.onColumnCheckChange,scope:this});c.push(d);e.on({destroy:Ext.Function.bind(d.destroy,d)})}return c},onColumnCheckChange:function(a,b){var c=Ext.getCmp(a.headerId);c[b?"show":"hide"]()},getColumnsForTpl:function(e){var c=[],d=this.getGridColumns(e),h=d.length,a=0,g,b;for(;a<h;a++){g=d[a];if(g.hidden||g.up("headercontainer[hidden=true]")){b=0}else{b=g.getDesiredWidth()}c.push({dataIndex:g.dataIndex,align:g.align,width:b,id:g.id,cls:g.tdCls,columnId:g.getItemId()})}return c},getColumnCount:function(){return this.getGridColumns().length},getFullWidth:function(d){var c=0,b=this.getVisibleGridColumns(d),g=b.length,a=0,e;for(;a<g;a++){e=b[a];if(e.getDesiredWidth){c+=e.getDesiredWidth()||0}else{c+=e.getWidth()}}return c},clearOtherSortStates:function(a){var c=this.getGridColumns(),d=c.length,b=0;for(;b<d;b++){if(c[b]!==a){c[b].setSortState(null,true)}}},getVisibleGridColumns:function(a){return Ext.ComponentQuery.query(":not([hidden])",this.getGridColumns(a))},getGridColumns:function(b){var c=this,a=b?null:c.gridDataColumns;if(!a){c.gridDataColumns=a=[];c.cascade(function(d){if((d!==c)&&!d.isGroupHeader){a.push(d)}})}return a},getHideableColumns:function(b){var c=this,a=b?null:c.hideableColumns;if(!a){a=c.hideableColumns=c.query("[hideable]")}return a},getHeaderIndex:function(a){if(a.isGroupHeader){a=a.down(":not([isgroupHeader])")}return Ext.Array.indexOf(this.getGridColumns(),a)},getHeaderAtIndex:function(a){var b=this.getGridColumns();return b.length?b[a]:null},getVisibleHeaderClosestToIndex:function(b){var a=this.getHeaderAtIndex(b);if(a&&a.hidden){a=a.next(":not([hidden])")||a.prev(":not([hidden])")}return a},prepareData:function(i,c,k,n,a){var m=this,h={},d=m.gridDataColumns||m.getGridColumns(),e=d.length,g=0,j,q,l,p,b,o=a.store;for(;g<e;g++){b={tdCls:"",style:""};j=d[g];q=j.id;l=j.renderer;p=i[j.dataIndex];if(typeof l=="function"){p=l.call(j.scope||m.ownerCt,p,b,k,c,g,o,n)}if(m.markDirty){h[q+"-modified"]=k.isModified(j.dataIndex)?Ext.baseCSSPrefix+"grid-dirty-cell":""}h[q+"-tdCls"]=b.tdCls;h[q+"-tdAttr"]=b.tdAttr;h[q+"-style"]=b.style;if(typeof p==="undefined"||p===null||p===""){p=j.emptyCellText}h[q]=p}return h},expandToFit:function(b){var a=this.view;if(a){a.expandToFit(b)}}});Ext.define("Ext.grid.column.Column",{extend:"Ext.grid.header.Container",alias:"widget.gridcolumn",requires:["Ext.util.KeyNav","Ext.grid.ColumnComponentLayout","Ext.grid.ColumnLayout"],alternateClassName:"Ext.grid.Column",baseCls:Ext.baseCSSPrefix+"column-header "+Ext.baseCSSPrefix+"unselectable",hoverCls:Ext.baseCSSPrefix+"column-header-over",handleWidth:5,sortState:null,possibleSortStates:["ASC","DESC"],childEls:["titleEl","triggerEl","textEl"],renderTpl:'<div id="{id}-titleEl" {tipMarkup}class="'+Ext.baseCSSPrefix+'column-header-inner"><span id="{id}-textEl" class="'+Ext.baseCSSPrefix+'column-header-text">{text}</span><tpl if="!menuDisabled"><div id="{id}-triggerEl" class="'+Ext.baseCSSPrefix+'column-header-trigger"></div></tpl></div>{%this.renderContainer(out,values)%}',dataIndex:null,text:"&#160;",menuText:null,emptyCellText:"&#160;",sortable:true,resizable:true,hideable:true,menuDisabled:false,renderer:false,editRenderer:false,align:"left",draggable:true,tooltipType:"qtip",initDraggable:Ext.emptyFn,isHeader:true,componentLayout:"columncomponent",initResizable:Ext.emptyFn,initComponent:function(){var a=this,b;if(Ext.isDefined(a.header)){a.text=a.header;delete a.header}if(!a.triStateSort){a.possibleSortStates.length=2}if(Ext.isDefined(a.columns)){a.isGroupHeader=true;a.items=a.columns;delete a.columns;delete a.flex;delete a.width;a.cls=(a.cls||"")+" "+Ext.baseCSSPrefix+"group-header";a.sortable=false;a.resizable=false;a.align="center"}else{a.isContainer=false;if(a.flex){a.minWidth=a.minWidth||Ext.grid.plugin.HeaderResizer.prototype.minColWidth}}a.addCls(Ext.baseCSSPrefix+"column-header-align-"+a.align);b=a.renderer;if(b){if(typeof b=="string"){a.renderer=Ext.util.Format[b]}a.hasCustomRenderer=true}else{if(a.defaultRenderer){a.scope=a;a.renderer=a.defaultRenderer}}a.callParent(arguments);a.on({element:"el",click:a.onElClick,dblclick:a.onElDblClick,scope:a});a.on({element:"titleEl",mouseenter:a.onTitleMouseOver,mouseleave:a.onTitleMouseOut,scope:a})},onAdd:function(a){a.isSubHeader=true;a.addCls(Ext.baseCSSPrefix+"group-sub-header");this.callParent(arguments)},onRemove:function(a){a.isSubHeader=false;a.removeCls(Ext.baseCSSPrefix+"group-sub-header");this.callParent(arguments)},initRenderData:function(){var b=this,d="",c=b.tooltip,a=b.tooltipType=="qtip"?"data-qtip":"title";if(!Ext.isEmpty(c)){d=a+'="'+c+'" '}return Ext.applyIf(b.callParent(arguments),{text:b.text,menuDisabled:b.menuDisabled,tipMarkup:d})},applyColumnState:function(b){var a=this,c=Ext.isDefined;a.applyColumnsState(b.columns);if(c(b.hidden)){a.hidden=b.hidden}if(c(b.locked)){a.locked=b.locked}if(c(b.sortable)){a.sortable=b.sortable}if(c(b.width)){delete a.flex;a.width=b.width}else{if(c(b.flex)){delete a.width;a.flex=b.flex}}},getColumnState:function(){var e=this,b=e.items.items,a=b?b.length:0,d,c=[],g={id:e.getStateId()};e.savePropsToState(["hidden","sortable","locked","flex","width"],g);if(e.isGroupHeader){for(d=0;d<a;d++){c.push(b[d].getColumnState())}if(c.length){g.columns=c}}else{if(e.isSubHeader&&e.ownerCt.hidden){delete e.hidden}}if("width" in g){delete g.flex}return g},getStateId:function(){return this.stateId||this.headerId},setText:function(a){this.text=a;if(this.rendered){this.textEl.update(a)}},getOwnerHeaderCt:function(){return this.up(":not([isHeader])")},getIndex:function(){return this.isGroupColumn?false:this.getOwnerHeaderCt().getHeaderIndex(this)},getVisibleIndex:function(){return this.isGroupColumn?false:Ext.Array.indexOf(this.getOwnerHeaderCt().getVisibleGridColumns(),this)},beforeRender:function(){var b=this,a=b.up("tablepanel");b.callParent();if(a&&(!b.sortable||a.sortableColumns===false)&&!b.groupable&&!b.lockable&&(a.enableColumnHide===false||!b.getOwnerHeaderCt().getHideableColumns().length)){b.menuDisabled=true}},afterRender:function(){var b=this,a=b.el;b.callParent(arguments);if(b.overCls){a.addClsOnOver(b.overCls)}if(!Ext.isIE8||!Ext.isStrict){b.mon(b.getFocusEl(),{focus:b.onTitleMouseOver,blur:b.onTitleMouseOut,scope:b})}b.keyNav=new Ext.util.KeyNav(a,{enter:b.onEnterKey,down:b.onDownKey,scope:b})},afterComponentLayout:function(d,a,c,g){var e=this,b=e.getOwnerHeaderCt();e.callParent(arguments);if(b&&(c!=null||e.flex)&&d!==c){b.onHeaderResize(e,d,true)}},setPadding:function(a){var e=this,d=parseInt(e.textEl.getStyle("line-height"),10),h=e.textEl.dom.offsetHeight,b=e.titleEl,g=a-e.el.getBorderWidth("tb"),c;if(!e.isGroupHeader){if(b.getHeight()<g){b.setHeight(g);e.ownerCt.layout.innerCt.setHeight(a)}}c=b.getViewSize().height;if(h){if(d){h=Math.ceil(h/d)*d}b.setStyle({paddingTop:Math.floor(Math.max(((c-h)/2),0))+"px"})}if(Ext.isIE&&e.triggerEl){e.triggerEl.setHeight(c)}},onDestroy:function(){var a=this;Ext.destroy(a.textEl,a.keyNav,a.field);delete a.keyNav;a.callParent(arguments)},onTitleMouseOver:function(){this.titleEl.addCls(this.hoverCls)},onTitleMouseOut:function(){this.titleEl.removeCls(this.hoverCls)},onDownKey:function(a){if(this.triggerEl){this.onElClick(a,this.triggerEl.dom||this.el.dom)}},onEnterKey:function(a){this.onElClick(a,this.el.dom)},onElDblClick:function(d,a){var c=this,b=c.ownerCt;if(b&&Ext.Array.indexOf(b.items,c)!==0&&c.isOnLeftEdge(d)){b.expandToFit(c.previousSibling("gridcolumn"))}},onElClick:function(d,b){var c=this,a=c.getOwnerHeaderCt();if(a&&!a.ddLock){if(c.triggerEl&&(d.target===c.triggerEl.dom||b===c.triggerEl.dom||d.within(c.triggerEl))){a.onHeaderTriggerClick(c,d,b)}else{if(d.getKey()||(!c.isOnLeftEdge(d)&&!c.isOnRightEdge(d))){c.toggleSortState();a.onHeaderClick(c,d,b)}}}},processEvent:function(g,b,a,c,d,h){return this.fireEvent.apply(this,arguments)},toggleSortState:function(){var b=this,a,c;if(b.sortable){a=Ext.Array.indexOf(b.possibleSortStates,b.sortState);c=(a+1)%b.possibleSortStates.length;b.setSortState(b.possibleSortStates[c])}},doSort:function(b){var a=this.up("tablepanel").store;a.sort({property:this.getSortParam(),direction:b})},getSortParam:function(){return this.dataIndex},setSortState:function(a,k,g){var h=this,i=Ext.baseCSSPrefix+"column-header-sort-",j=i+"ASC",c=i+"DESC",b=i+"null",e=h.getOwnerHeaderCt(),d=h.sortState;if(d!==a&&h.getSortParam()){h.addCls(i+a);if(a&&!g){h.doSort(a)}switch(a){case"DESC":h.removeCls([j,b]);break;case"ASC":h.removeCls([c,b]);break;case null:h.removeCls([j,c]);break}if(e&&!h.triStateSort&&!k){e.clearOtherSortStates(h)}h.sortState=a;if(h.triStateSort||a!=null){e.fireEvent("sortchange",e,h,a)}}},hide:function(c){var j=this,e=j.getOwnerHeaderCt(),b=j.ownerCt,a=b.isGroupHeader,k,h,g,d;if(a&&!c){h=b.query(">:not([hidden])");if(h.length===1&&h[0]==j){j.ownerCt.hide();return}}Ext.suspendLayouts();if(j.isGroupHeader){h=j.items.items;for(d=0,g=h.length;d<g;d++){k=h[d];if(!k.hidden){k.hide(true)}}}j.callParent();e.onHeaderHide(j);Ext.resumeLayouts(true)},show:function(d,b){var j=this,g=j.ownerCt,c,a,e,h;Ext.suspendLayouts();if(j.isSubHeader&&g.hidden){g.show(false,true)}j.callParent(arguments);if(j.isGroupHeader&&b!==true&&!j.query(":not([hidden])").length){c=j.query(">*");for(e=0,a=c.length;e<a;e++){h=c[e];if(h.hidden){h.show(true)}}}Ext.resumeLayouts(true);g=j.getOwnerHeaderCt();if(g){g.onHeaderShow(j)}},getDesiredWidth:function(){var a=this;if(a.rendered&&a.componentLayout&&a.componentLayout.lastComponentSize){return a.componentLayout.lastComponentSize.width}else{if(a.flex){return a.width}else{return a.width}}},getCellSelector:function(){return"."+Ext.baseCSSPrefix+"grid-cell-"+this.getItemId()},getCellInnerSelector:function(){return this.getCellSelector()+" ."+Ext.baseCSSPrefix+"grid-cell-inner"},isOnLeftEdge:function(a){return(a.getXY()[0]-this.el.getLeft()<=this.handleWidth)},isOnRightEdge:function(a){return(this.el.getRight()-a.getXY()[0]<=this.handleWidth)}});Ext.define("Ext.grid.RowNumberer",{extend:"Ext.grid.column.Column",alias:"widget.rownumberer",text:"&#160",width:23,sortable:false,draggable:false,align:"right",constructor:function(a){this.width=this.width;this.callParent(arguments);if(this.rowspan){this.renderer=Ext.Function.bind(this.renderer,this)}},resizable:false,hideable:false,menuDisabled:true,dataIndex:"",cls:Ext.baseCSSPrefix+"row-numberer",rowspan:undefined,renderer:function(e,b,a,d,g,c){if(this.rowspan){b.cellAttr='rowspan="'+this.rowspan+'"'}b.tdCls=Ext.baseCSSPrefix+"grid-cell-special";return c.indexOfTotal(a)+1}});Ext.define("Ext.view.DropZone",{extend:"Ext.dd.DropZone",indicatorHtml:'<div class="'+Ext.baseCSSPrefix+'grid-drop-indicator-left"></div><div class="'+Ext.baseCSSPrefix+'grid-drop-indicator-right"></div>',indicatorCls:Ext.baseCSSPrefix+"grid-drop-indicator",constructor:function(a){var b=this;Ext.apply(b,a);if(!b.ddGroup){b.ddGroup="view-dd-zone-"+b.view.id}b.callParent([b.view.el])},fireViewEvent:function(){var b=this,a;b.lock();a=b.view.fireEvent.apply(b.view,arguments);b.unlock();return a},getTargetFromEvent:function(k){var j=k.getTarget(this.view.getItemSelector()),d,c,b,g,a,h;if(!j){d=k.getPageY();for(g=0,c=this.view.getNodes(),a=c.length;g<a;g++){b=c[g];h=Ext.fly(b).getBox();if(d<=h.bottom){return b}}}return j},getIndicator:function(){var a=this;if(!a.indicator){a.indicator=new Ext.Component({html:a.indicatorHtml,cls:a.indicatorCls,ownerCt:a.view,floating:true,shadow:false})}return a.indicator},getPosition:function(c,a){var g=c.getXY()[1],b=Ext.fly(a).getRegion(),d;if((b.bottom-g)>=(b.bottom-b.top)/2){d="before"}else{d="after"}return d},containsRecordAtOffset:function(d,b,g){if(!b){return false}var a=this.view,c=a.indexOf(b),e=a.getNode(c+g),h=e?a.getRecord(e):null;return h&&Ext.Array.contains(d,h)},positionIndicator:function(b,c,d){var g=this,i=g.view,h=g.getPosition(d,b),k=i.getRecord(b),a=c.records,j;if(!Ext.Array.contains(a,k)&&(h=="before"&&!g.containsRecordAtOffset(a,k,-1)||h=="after"&&!g.containsRecordAtOffset(a,k,1))){g.valid=true;if(g.overRecord!=k||g.currentPosition!=h){j=Ext.fly(b).getY()-i.el.getY()-1;if(h=="after"){j+=Ext.fly(b).getHeight()}g.getIndicator().setWidth(Ext.fly(i.el).getWidth()).showAt(0,j);g.overRecord=k;g.currentPosition=h}}else{g.invalidateDrop()}},invalidateDrop:function(){if(this.valid){this.valid=false;this.getIndicator().hide()}},onNodeOver:function(c,a,g,d){var b=this;if(!Ext.Array.contains(d.records,b.view.getRecord(c))){b.positionIndicator(c,d,g)}return b.valid?b.dropAllowed:b.dropNotAllowed},notifyOut:function(c,a,g,d){var b=this;b.callParent(arguments);delete b.overRecord;delete b.currentPosition;if(b.indicator){b.indicator.hide()}},onContainerOver:function(a,h,g){var d=this,b=d.view,c=b.store.getCount();if(c){d.positionIndicator(b.getNode(c-1),g,h)}else{delete d.overRecord;delete d.currentPosition;d.getIndicator().setWidth(Ext.fly(b.el).getWidth()).showAt(0,0);d.valid=true}return d.dropAllowed},onContainerDrop:function(a,c,b){return this.onNodeDrop(a,null,c,b)},onNodeDrop:function(g,a,i,h){var d=this,c=false,b={wait:false,processDrop:function(){d.invalidateDrop();d.handleNodeDrop(h,d.overRecord,d.currentPosition);c=true;d.fireViewEvent("drop",g,h,d.overRecord,d.currentPosition)},cancelDrop:function(){d.invalidateDrop();c=true}},j=false;if(d.valid){j=d.fireViewEvent("beforedrop",g,h,d.overRecord,d.currentPosition,b);if(b.wait){return}if(j!==false){if(!c){b.processDrop()}}}return j},destroy:function(){Ext.destroy(this.indicator);delete this.indicator;this.callParent()}});Ext.define("Ext.grid.ViewDropZone",{extend:"Ext.view.DropZone",indicatorHtml:'<div class="'+Ext.baseCSSPrefix+'grid-drop-indicator-left"></div><div class="'+Ext.baseCSSPrefix+'grid-drop-indicator-right"></div>',indicatorCls:Ext.baseCSSPrefix+"grid-drop-indicator",handleNodeDrop:function(b,d,e){var j=this.view,k=j.getStore(),h,a,c,g;if(b.copy){a=b.records;b.records=[];for(c=0,g=a.length;c<g;c++){b.records.push(a[c].copy(a[c].getId()))}}else{b.view.store.remove(b.records,b.view===j)}h=k.indexOf(d);if(e!=="before"){h++}k.insert(h,b.records);j.getSelectionModel().select(b.records)}});Ext.define("Ext.grid.column.Action",{extend:"Ext.grid.column.Column",alias:["widget.actioncolumn"],alternateClassName:"Ext.grid.ActionColumn",actionIdRe:new RegExp(Ext.baseCSSPrefix+"action-col-(\\d+)"),altText:"",menuText:"<i>Actions</i>",sortable:false,constructor:function(d){var g=this,b=Ext.apply({},d),c=b.items||[g],h,e,a;g.origRenderer=b.renderer||g.renderer;g.origScope=b.scope||g.scope;delete g.renderer;delete g.scope;delete b.renderer;delete b.scope;delete b.items;g.callParent([b]);g.items=c;for(e=0,a=c.length;e<a;++e){if(c[e].getClass){h=true;break}}if(g.origRenderer||h){g.hasCustomRenderer=true}},defaultRenderer:function(g,j){var e=this,b=Ext.baseCSSPrefix,k=e.origScope||e,d=e.items,c=d.length,a=0,h;g=Ext.isFunction(e.origRenderer)?e.origRenderer.apply(k,arguments)||"":"";j.tdCls+=" "+Ext.baseCSSPrefix+"action-col-cell";for(;a<c;a++){h=d[a];if(!h.hasActionConfiguration){h.stopSelection=e.stopSelection;h.disable=Ext.Function.bind(e.disableAction,e,[a],0);h.enable=Ext.Function.bind(e.enableAction,e,[a],0);h.hasActionConfiguration=true}g+='<img alt="'+(h.altText||e.altText)+'" src="'+(h.icon||Ext.BLANK_IMAGE_URL)+'" class="'+b+"action-col-icon "+b+"action-col-"+String(a)+" "+(h.disabled?b+"item-disabled":" ")+" "+(Ext.isFunction(h.getClass)?h.getClass.apply(h.scope||k,arguments):(h.iconCls||e.iconCls||""))+'"'+((h.tooltip)?' data-qtip="'+h.tooltip+'"':"")+" />"}return g},enableAction:function(b,a){var c=this;if(!b){b=0}else{if(!Ext.isNumber(b)){b=Ext.Array.indexOf(c.items,b)}}c.items[b].disabled=false;c.up("tablepanel").el.select("."+Ext.baseCSSPrefix+"action-col-"+b).removeCls(c.disabledCls);if(!a){c.fireEvent("enable",c)}},disableAction:function(b,a){var c=this;if(!b){b=0}else{if(!Ext.isNumber(b)){b=Ext.Array.indexOf(c.items,b)}}c.items[b].disabled=true;c.up("tablepanel").el.select("."+Ext.baseCSSPrefix+"action-col-"+b).addCls(c.disabledCls);if(!a){c.fireEvent("disable",c)}},destroy:function(){delete this.items;delete this.renderer;return this.callParent(arguments)},processEvent:function(i,l,n,a,j,g,c,p){var h=this,d=g.getTarget(),b,o,k,m=i=="keydown"&&g.getKey();if(m&&!Ext.fly(d).findParent(l.cellSelector)){d=Ext.fly(n).down("."+Ext.baseCSSPrefix+"action-col-icon",true)}if(d&&(b=d.className.match(h.actionIdRe))){o=h.items[parseInt(b[1],10)];if(o){if(i=="click"||(m==g.ENTER||m==g.SPACE)){k=o.handler||h.handler;if(k&&!o.disabled){k.call(o.scope||h.origScope||h,l,a,j,o,g,c,p)}}else{if(i=="mousedown"&&o.stopSelection!==false){return false}}}}return h.callParent(arguments)},cascade:function(b,a){b.call(a||this,this)},getRefItems:function(){return[]}});Ext.define("Ext.grid.column.Boolean",{extend:"Ext.grid.column.Column",alias:["widget.booleancolumn"],alternateClassName:"Ext.grid.BooleanColumn",trueText:"true",falseText:"false",undefinedText:"&#160;",defaultRenderer:function(a){if(a===undefined){return this.undefinedText}if(!a||a==="false"){return this.falseText}return this.trueText}});Ext.define("Ext.grid.column.Date",{extend:"Ext.grid.column.Column",alias:["widget.datecolumn"],requires:["Ext.Date"],alternateClassName:"Ext.grid.DateColumn",initComponent:function(){if(!this.format){this.format=Ext.Date.defaultFormat}this.callParent(arguments)},defaultRenderer:function(a){return Ext.util.Format.date(a,this.format)}});Ext.define("Ext.grid.column.Number",{extend:"Ext.grid.column.Column",alias:["widget.numbercolumn"],requires:["Ext.util.Format"],alternateClassName:"Ext.grid.NumberColumn",format:"0,000.00",defaultRenderer:function(a){return Ext.util.Format.number(a,this.format)}});Ext.define("Ext.grid.column.Template",{extend:"Ext.grid.column.Column",alias:["widget.templatecolumn"],requires:["Ext.XTemplate"],alternateClassName:"Ext.grid.TemplateColumn",initComponent:function(){var a=this;a.tpl=(!Ext.isPrimitive(a.tpl)&&a.tpl.compile)?a.tpl:new Ext.XTemplate(a.tpl);a.hasCustomRenderer=true;a.callParent(arguments)},defaultRenderer:function(c,d,a){var b=Ext.apply({},a.data,a.getAssociatedData());return this.tpl.apply(b)}});Ext.define("Ext.grid.feature.Feature",{extend:"Ext.util.Observable",alias:"feature.feature",isFeature:true,disabled:false,hasFeatureEvent:true,eventPrefix:null,eventSelector:null,view:null,grid:null,collectData:false,constructor:function(a){this.initialConfig=a;this.callParent(arguments)},clone:function(){return new this.self(this.initialConfig)},init:Ext.emptyFn,getFeatureTpl:function(){return""},getFireEventArgs:function(b,a,c,d){return[b,a,c,d]},attachEvents:function(){},getFragmentTpl:Ext.emptyFn,mutateMetaRowTpl:Ext.emptyFn,getMetaRowTplFragments:function(){return{}},getTableFragments:function(){return{}},getAdditionalData:function(c,a,b,d){return{}},enable:function(){this.disabled=false},disable:function(){this.disabled=true}});Ext.define("Ext.grid.feature.AbstractSummary",{extend:"Ext.grid.feature.Feature",alias:"feature.abstractsummary",showSummaryRow:true,nestedIdRe:/\{\{id\}([\w\-]*)\}/g,init:function(){var a=this;a.grid.optimizedColumnMove=false;a.view.mon(a.view.store,{update:a.onStoreUpdate,scope:a})},onStoreUpdate:function(){var a=this.view;if(this.showSummaryRow){a.saveScrollState();a.refresh();a.restoreScrollState()}},toggleSummaryRow:function(a){this.showSummaryRow=!!a},getSummaryFragments:function(){var a={};if(this.showSummaryRow){Ext.apply(a,{printSummaryRow:Ext.bind(this.printSummaryRow,this)})}return a},printSummaryRow:function(b){var a=this.view.getTableChunker().metaRowTpl.join(""),c=Ext.baseCSSPrefix;a=a.replace(c+"grid-row",c+"grid-row-summary");a=a.replace("{{id}}","{gridSummaryValue}");a=a.replace(this.nestedIdRe,"{id$1}");a=a.replace("{[this.embedRowCls()]}","{rowCls}");a=a.replace("{[this.embedRowAttr()]}","{rowAttr}");a=new Ext.XTemplate(a,{firstOrLastCls:Ext.view.TableChunker.firstOrLastCls});return a.applyTemplate({columns:this.getPrintData(b)})},getColumnValue:function(c,a){var b=Ext.getCmp(c.id),e=a[c.id],d=b.summaryRenderer;if(!e&&e!==0){e="\u00a0"}if(d){e=d.call(b.scope||this,e,a,c.dataIndex)}return e},getSummary:function(a,b,d,c){if(b){if(Ext.isFunction(b)){return a.aggregate(b,null,c)}switch(b){case"count":return a.count(c);case"min":return a.min(d,c);case"max":return a.max(d,c);case"sum":return a.sum(d,c);case"average":return a.average(d,c);default:return c?{}:""}}}});Ext.define("Ext.grid.feature.Chunking",{extend:"Ext.grid.feature.Feature",alias:"feature.chunking",chunkSize:20,rowHeight:Ext.isIE?27:26,visibleChunk:0,hasFeatureEvent:false,attachEvents:function(){this.view.el.on("scroll",this.onBodyScroll,this,{buffer:300})},onBodyScroll:function(g,c){var b=this.view,d=c.scrollTop,a=Math.floor(d/this.rowHeight/this.chunkSize);if(a!==this.visibleChunk){this.visibleChunk=a;b.refresh();b.el.dom.scrollTop=d;b.el.dom.scrollTop=d}},collectData:function(d,m,l,k,c){var j=this,e=c.rows.length,b=0,g=0,a=j.visibleChunk,p,n,h=c.rows;delete c.rows;c.chunks=[];for(;b<e;b+=j.chunkSize,g++){if(b+j.chunkSize>e){n=e-b}else{n=j.chunkSize}if(g>=a-1&&g<=a+1){p=h.slice(b,b+j.chunkSize)}else{p=[]}c.chunks.push({rows:p,fullWidth:k,chunkHeight:n*j.rowHeight})}return c},getTableFragments:function(){return{openTableWrap:function(){return'<tpl for="chunks"><div class="'+Ext.baseCSSPrefix+'grid-chunk" style="height: {chunkHeight}px;">'},closeTableWrap:function(){return"</div></tpl>"}}}});Ext.define("Ext.grid.feature.Grouping",{extend:"Ext.grid.feature.Feature",alias:"feature.grouping",eventPrefix:"group",eventSelector:"."+Ext.baseCSSPrefix+"grid-group-hd",bodySelector:"."+Ext.baseCSSPrefix+"grid-group-body",constructor:function(){var a=this;a.collapsedState={};a.callParent(arguments)},groupHeaderTpl:"{columnName}: {name}",depthToIndent:17,collapsedCls:Ext.baseCSSPrefix+"grid-group-collapsed",hdCollapsedCls:Ext.baseCSSPrefix+"grid-group-hd-collapsed",hdCollapsibleCls:Ext.baseCSSPrefix+"grid-group-hd-collapsible",groupByText:"Group by this field",showGroupsText:"Show in groups",hideGroupedHeader:false,startCollapsed:false,enableGroupingMenu:true,enableNoGroups:true,collapsible:true,enable:function(){var c=this,a=c.view,b=a.store,d;c.lastGroupField=c.getGroupField();if(c.lastGroupIndex){c.block();b.group(c.lastGroupIndex);c.unblock()}c.callParent();d=c.view.headerCt.getMenu().down("#groupToggleMenuItem");d.setChecked(true,true);c.refreshIf()},disable:function(){var d=this,a=d.view,b=a.store,g=b.remoteGroup,e,c;c=b.groupers.first();if(c){d.lastGroupIndex=c.property;d.block();b.clearGrouping();d.unblock()}d.callParent();e=d.view.headerCt.getMenu().down("#groupToggleMenuItem");e.setChecked(true,true);e.setChecked(false,true);d.refreshIf()},refreshIf:function(){var b=this.grid.ownerCt,a=this.view;if(!a.store.remoteGroup&&!this.blockRefresh){if(b&&b.lockable){b.view.refresh()}else{a.refresh()}}},getFeatureTpl:function(b,c,a,d){return["<tpl if=\"typeof rows !== 'undefined'\">",'<tr id="{groupHeaderId}" class="'+Ext.baseCSSPrefix+'grid-group-hd {hdCollapsedCls} {collapsibleClass}"><td class="'+Ext.baseCSSPrefix+'grid-cell" colspan="'+c.columns.length+'" {[this.indentByDepth(values)]}><div class="'+Ext.baseCSSPrefix+'grid-cell-inner"><div class="'+Ext.baseCSSPrefix+'grid-group-title">{collapsed}{[this.renderGroupHeaderTpl(values, parent)]}</div></div></td></tr>','<tr id="{groupBodyId}" class="'+Ext.baseCSSPrefix+'grid-group-body {collapsedCls}"><td colspan="'+c.columns.length+'">{[this.recurse(values)]}</td></tr>',"</tpl>"].join("")},getFragmentTpl:function(){var a=this;return{indentByDepth:a.indentByDepth,depthToIndent:a.depthToIndent,renderGroupHeaderTpl:function(b,c){return Ext.XTemplate.getTpl(a,"groupHeaderTpl").apply(b,c)}}},indentByDepth:function(a){return'style="padding-left:'+((a.depth||0)*this.depthToIndent)+'px;"'},destroy:function(){delete this.view;delete this.prunedHeader},attachEvents:function(){var b=this,a=b.view;a.on({scope:b,groupclick:b.onGroupClick,rowfocus:b.onRowFocus});a.mon(a.store,{scope:b,groupchange:b.onGroupChange,remove:b.onRemove,add:b.onAdd,update:b.onUpdate});if(b.enableGroupingMenu){b.injectGroupingMenu()}b.pruneGroupedHeader();b.lastGroupField=b.getGroupField();b.block();b.onGroupChange();b.unblock()},onAdd:function(l,c){var j=this,k=j.view,a=j.getGroupField(),g=0,h=c.length,n,d,b,e,m;if(k.rendered){d={};n={};for(;g<h;++g){m=c[g].get(a);if(d[m]===undefined){d[m]=0}d[m]+=1}b=l.getGroups();for(g=0,h=b.length;g<h;++g){m=b[g];n[m.name]=m.children.length}for(m in d){if(d[m]===n[m]){e=true;break}}if(e){k.refresh()}}},onUpdate:function(c,b,d,e){var a=this.view;if(a.rendered&&!e||Ext.Array.contains(e,this.getGroupField())){a.refresh()}},onRemove:function(d,c){var e=this,b=e.getGroupField(),g=c.get(b),a=e.view;if(a.rendered){if(d.findExact(b,g)===-1){e.view.refresh()}}},injectGroupingMenu:function(){var a=this,b=a.view.headerCt;b.showMenuBy=a.showMenuBy;b.getMenuItems=a.getMenuItems()},showMenuBy:function(b,e){var d=this.getMenu(),c=d.down("#groupMenuItem"),a=e.groupable===false?"disable":"enable";c[a]();Ext.grid.header.Container.prototype.showMenuBy.apply(this,arguments)},getMenuItems:function(){var g=this,c=g.groupByText,e=g.disabled||!g.getGroupField(),a=g.showGroupsText,d=g.enableNoGroups,b=g.view.headerCt.getMenuItems;return function(){var h=b.call(this);h.push("-",{iconCls:Ext.baseCSSPrefix+"group-by-icon",itemId:"groupMenuItem",text:c,handler:g.onGroupMenuItemClick,scope:g});if(d){h.push({itemId:"groupToggleMenuItem",text:a,checked:!e,checkHandler:g.onGroupToggleMenuItemClick,scope:g})}return h}},onGroupMenuItemClick:function(c,g){var d=this,h=c.parentMenu,i=h.activeHeader,a=d.view,b=a.store;delete d.lastGroupIndex;d.block();d.enable();b.group(i.dataIndex);d.pruneGroupedHeader();d.unblock();d.refreshIf()},block:function(){this.blockRefresh=this.view.blockRefresh=true},unblock:function(){this.blockRefresh=this.view.blockRefresh=false},onGroupToggleMenuItemClick:function(a,b){this[b?"enable":"disable"]()},pruneGroupedHeader:function(){var a=this,b=a.getGroupedHeader();if(a.hideGroupedHeader&&b){if(a.prunedHeader){a.prunedHeader.show()}a.prunedHeader=b;b.hide()}},getGroupedHeader:function(){var a=this.getGroupField(),b=this.view.headerCt;return a?b.down("[dataIndex="+a+"]"):null},getGroupField:function(){var a=this.view.store.groupers.first();if(a){return a.property}return""},onRowFocus:function(c){var b=this.view.getNode(c),a=Ext.fly(b).up("."+this.collapsedCls);if(a){this.expand(a)}},isExpanded:function(a){return(this.collapsedState[a]===false)},expand:function(i,b,h){var e=this,a=e.view,c,g,d=e.lockingPartner;if(Ext.isString(i)){g=Ext.fly(e.getGroupBodyId(i),"_grouping")}else{g=Ext.fly(i,"_grouping");i=e.getGroupName(g)}c=Ext.get(e.getGroupHeaderId(i));if(e.collapsedState[i]){g.removeCls(e.collapsedCls);g.prev().removeCls(e.hdCollapsedCls);if(h!==true){a.refreshSize()}a.fireEvent("groupexpand",a,c,i);e.collapsedState[i]=false;if(d){d.expand(i,b,h)}if(b){g.scrollIntoView(a.el,null,true)}}},expandAll:function(){var d=this,b=d.view,c=b.el.select(d.eventSelector).elements,g,a=c.length;for(g=0;g<a;g++){d.expand(Ext.fly(c[g]).next(),false,true)}b.refreshSize()},collapse:function(i,b,h){var e=this,a=e.view,c,g,d=e.lockingPartner;if(Ext.isString(i)){g=Ext.fly(e.getGroupBodyId(i),"_grouping")}else{g=Ext.fly(i,"_grouping");i=e.getGroupName(g)}c=Ext.get(e.getGroupHeaderId(i));if(!e.collapsedState[i]){g.addCls(e.collapsedCls);g.prev().addCls(e.hdCollapsedCls);if(h!==true){a.refreshSize()}a.fireEvent("groupcollapse",a,c,i);e.collapsedState[i]=true;if(d){d.collapse(i,b,h)}if(b){c.scrollIntoView(a.el,null,true)}}},collapseAll:function(){var d=this,b=d.view,c=b.el.select(d.eventSelector).elements,g,a=c.length;for(g=0;g<a;g++){d.collapse(Ext.fly(c[g]).next(),false,true)}b.refreshSize()},onGroupChange:function(){var d=this,e=d.getGroupField(),c,a,b;if(d.hideGroupedHeader){if(d.lastGroupField){c=d.getMenuItem(d.lastGroupField);if(c){c.setChecked(true)}}if(e){a=d.view.headerCt.getVisibleGridColumns();b=((a.length===1)&&(a[0].dataIndex==e));c=d.getMenuItem(e);if(c&&!b){c.setChecked(false)}}}d.refreshIf();d.lastGroupField=e},getMenuItem:function(b){var a=this.view,d=a.headerCt.down("gridcolumn[dataIndex="+b+"]"),c=a.headerCt.getMenu();return d?c.down("menuitem[headerId="+d.id+"]"):null},onGroupClick:function(a,c,g,d){var b=this;if(b.collapsible){if(b.collapsedState[g]){b.expand(g)}else{b.collapse(g)}}},getMetaRowTplFragments:function(){return{isRow:this.isRow,closeRow:this.closeRow}},isRow:function(){return"<tpl if=\"typeof rows === 'undefined'\">"},closeRow:function(){return"</tpl>"},mutateMetaRowTpl:function(a){a.unshift("{[this.isRow()]}");a.push("{[this.closeRow()]}")},getAdditionalData:function(e,j,g,i){var h=this.view,d=h.headerCt,c=d.items.getAt(0),b={},a;if(c){a=c.id+"-tdAttr";b[a]=this.indentByDepth(e)+" "+(i[a]?i[a]:"");b.collapsed="true";b.data=g.getData()}return b},getGroupRows:function(m,d,n,k){var i=this,c=m.children,o=m.rows=[],j=i.view,g=i.getGroupedHeader(),b=i.getGroupField(),h=-1,a,l=d.length,e;if(j.store.buffered){i.collapsible=false}m.viewId=j.id;for(a=0;a<l;a++){e=d[a];if(e.get(b)==m.name){h=a}if(Ext.Array.indexOf(c,e)!=-1){o.push(Ext.apply(n[a],{depth:1}))}}m.groupField=b,m.groupHeaderId=i.getGroupHeaderId(m.name);m.groupBodyId=i.getGroupBodyId(m.name);m.fullWidth=k;m.columnName=g?g.text:b;m.groupValue=m.name;if(g&&h>-1){m.name=m.renderedValue=n[h][g.id]}if(i.collapsedState[m.name]){m.collapsedCls=i.collapsedCls;m.hdCollapsedCls=i.hdCollapsedCls}else{m.collapsedCls=m.hdCollapsedCls=""}if(i.collapsible){m.collapsibleClass=i.hdCollapsibleCls}else{m.collapsibleClass=""}return m},getGroupHeaderId:function(a){return this.view.id+"-hd-"+a},getGroupBodyId:function(a){return this.view.id+"-bd-"+a},getGroupName:function(a){var b=this,c;c=Ext.fly(a).findParent(b.eventSelector);if(c){return c.id.split(this.view.id+"-hd-")[1]}c=Ext.fly(a).findParent(b.bodySelector);if(c){return c.id.split(this.view.id+"-bd-")[1]}},collectData:function(c,p,n,k,a){var h=this,l=h.view.store,j=h.collapsedState,e,d,b,i,m;if(h.startCollapsed){h.startCollapsed=false;e=true}if(!h.disabled&&l.isGrouped()){a.rows=b=l.getGroups();i=b.length;for(d=0;d<i;d++){m=b[d];if(e){j[m.name]=true}h.getGroupRows(m,c,p,k)}}return a},getFireEventArgs:function(b,a,d,c){return[b,a,d,this.getGroupName(d),c]}});Ext.define("Ext.grid.feature.GroupingSummary",{extend:"Ext.grid.feature.Grouping",alias:"feature.groupingsummary",mixins:{summary:"Ext.grid.feature.AbstractSummary"},init:function(){this.mixins.summary.init.call(this)},getFeatureTpl:function(){var a=this.callParent(arguments);if(this.showSummaryRow){a=a.replace("</tpl>","");a+="{[this.printSummaryRow(xindex)]}</tpl>"}return a},getFragmentTpl:function(){var b=this,a=b.callParent();Ext.apply(a,b.getSummaryFragments());if(b.showSummaryRow){b.summaryGroups=b.view.store.getGroups();b.summaryData=b.generateSummaryData()}return a},getPrintData:function(j){var k=this,e=k.view.headerCt.getColumnsForTpl(),h=0,b=e.length,g=[],a=k.summaryGroups[j-1].name,d=k.summaryData[a],c;for(;h<b;++h){c=e[h];c.gridSummaryValue=this.getColumnValue(c,d);g.push(c)}return g},generateSummaryData:function(){var t=this,u={},n={},h=t.view.store,r=this.getGroupField(),a=h.proxy.reader,q=t.summaryGroups,b=t.view.headerCt.getColumnsForTpl(),j,o,e,c,m,v,p,k,l,g,d;for(o=0,e=q.length;o<e;++o){u[q[o].name]={}}if(t.remoteRoot&&a.rawData){m=a.root;a.root=t.remoteRoot;a.buildExtractors(true);k=a.getRoot(a.rawData);g=k.length;if(!a.convertRecordData){a.buildExtractors()}for(l=0;l<g;l++){d={};a.convertRecordData(d,k[l]);n[d[r]]=d}a.root=m;a.buildExtractors(true)}for(o=0,e=b.length;o<e;++o){p=Ext.getCmp(b[o].id);c=t.getSummary(h,p.summaryType,p.dataIndex,true);for(v in c){if(c.hasOwnProperty(v)){u[v][p.id]=c[v]}}for(v in n){if(n.hasOwnProperty(v)){j=n[v][p.dataIndex];if(j!==undefined&&u[v]!==undefined){u[v][p.id]=j}}}}return u}});Ext.define("Ext.grid.feature.RowBody",{extend:"Ext.grid.feature.Feature",alias:"feature.rowbody",rowBodyHiddenCls:Ext.baseCSSPrefix+"grid-row-body-hidden",rowBodyTrCls:Ext.baseCSSPrefix+"grid-rowbody-tr",rowBodyTdCls:Ext.baseCSSPrefix+"grid-cell-rowbody",rowBodyDivCls:Ext.baseCSSPrefix+"grid-rowbody",eventPrefix:"rowbody",eventSelector:"."+Ext.baseCSSPrefix+"grid-rowbody-tr",getRowBody:function(a){return['<tr class="'+this.rowBodyTrCls+' {rowBodyCls}">','<td class="'+this.rowBodyTdCls+'" colspan="{rowBodyColspan}">','<div class="'+this.rowBodyDivCls+'">{rowBody}</div>',"</td>","</tr>"].join("")},getMetaRowTplFragments:function(){return{getRowBody:this.getRowBody,rowBodyTrCls:this.rowBodyTrCls,rowBodyTdCls:this.rowBodyTdCls,rowBodyDivCls:this.rowBodyDivCls}},mutateMetaRowTpl:function(a){a.push("{[this.getRowBody(values)]}")},getAdditionalData:function(c,a,b,g){var d=this.view.headerCt,e=d.getColumnCount();return{rowBody:"",rowBodyCls:this.rowBodyCls,rowBodyColspan:e}}});Ext.define("Ext.grid.feature.RowWrap",{extend:"Ext.grid.feature.Feature",alias:"feature.rowwrap",hasFeatureEvent:false,init:function(){if(!this.disabled){this.enable()}},getRowSelector:function(){return"tr:has(> "+this.view.cellSelector+")"},enable:function(){var b=this,a=b.view;b.callParent();b.savedRowSelector=a.rowSelector;a.rowSelector=b.getRowSelector();a.getComponentLayout().getColumnSelector=b.getColumnSelector},disable:function(){var c=this,a=c.view,b=c.savedRowSelector;c.callParent();if(b){a.rowSelector=b}delete c.savedRowSelector},mutateMetaRowTpl:function(a){var b=Ext.baseCSSPrefix;a[0]=a[0].replace(b+"grid-row","");a[0]=a[0].replace("{[this.embedRowCls()]}","");a.unshift('<table class="'+b+"grid-table "+b+'grid-table-resizer" style="width: {[this.embedFullWidth()]}px;">');a.unshift('<tr class="'+b+'grid-row {[this.embedRowCls()]}"><td colspan="{[this.embedColSpan()]}"><div class="'+b+'grid-rowwrap-div">');a.push("</table>");a.push("</div></td></tr>")},embedColSpan:function(){return"{colspan}"},embedFullWidth:function(){return"{fullWidth}"},getAdditionalData:function(h,p,k,m){var d=this.view.headerCt,c=d.getColumnCount(),n=d.getFullWidth(),l=d.query("gridcolumn"),q=l.length,g=0,b={colspan:c,fullWidth:n},a,j,e;for(;g<q;g++){a=l[g].id;j=a+"-tdCls";e=Ext.baseCSSPrefix+"grid-col-resizer-"+a;b[j]=e+" "+(m[j]?m[j]:"");b[a+"-tdAttr"]=' style="width: '+(l[g].hidden?0:l[g].getDesiredWidth())+'px;" ';if(m[a+"-tdAttr"]){b[a+"-tdAttr"]+=m[a+"-tdAttr"]}}return b},getMetaRowTplFragments:function(){return{embedFullWidth:this.embedFullWidth,embedColSpan:this.embedColSpan}},getColumnSelector:function(b){var a=Ext.baseCSSPrefix+"grid-col-resizer-"+b.id;return"th."+a+",td."+a}});Ext.define("Ext.grid.feature.Summary",{extend:"Ext.grid.feature.AbstractSummary",alias:"feature.summary",getFragmentTpl:function(){this.summaryData=this.generateSummaryData();return this.getSummaryFragments()},getTableFragments:function(){if(this.showSummaryRow){return{closeRows:this.closeRows}}},closeRows:function(){return"</tpl>{[this.printSummaryRow()]}"},getPrintData:function(a){var g=this,c=g.view.headerCt.getColumnsForTpl(),b=0,e=c.length,h=[],j=g.summaryData,d;for(;b<e;++b){d=c[b];d.gridSummaryValue=this.getColumnValue(d,j);h.push(d)}return h},generateSummaryData:function(){var h=this,d={},j=h.view.store,c=h.view.headerCt.getColumnsForTpl(),e=0,a=c.length,b,k,g;for(e=0,a=c.length;e<a;++e){g=Ext.getCmp(c[e].id);d[g.id]=h.getSummary(j,g.summaryType,g.dataIndex,false)}return d}});Ext.define("Ext.grid.plugin.Editing",{alias:"editing.editing",extend:"Ext.AbstractPlugin",requires:["Ext.grid.column.Column","Ext.util.KeyNav"],mixins:{observable:"Ext.util.Observable"},clicksToEdit:2,triggerEvent:undefined,defaultFieldXType:"textfield",editStyle:"",constructor:function(a){var b=this;b.addEvents("beforeedit","edit","validateedit","canceledit");b.callParent(arguments);b.mixins.observable.constructor.call(b);b.on("edit",function(c,d){b.fireEvent("afteredit",c,d)})},init:function(a){var b=this;b.grid=a;b.view=a.view;b.initEvents();b.mon(a,"reconfigure",b.onReconfigure,b);b.onReconfigure();a.relayEvents(b,["beforeedit","edit","validateedit","canceledit"]);a.isEditable=true;a.editingPlugin=a.view.editingPlugin=b},onReconfigure:function(){this.initFieldAccessors(this.view.getGridColumns())},destroy:function(){var b=this,a=b.grid;Ext.destroy(b.keyNav);b.removeFieldAccessors(a.getView().getGridColumns());b.clearListeners();delete b.grid.editingPlugin;delete b.grid.view.editingPlugin;delete b.grid;delete b.view;delete b.editor;delete b.keyNav},getEditStyle:function(){return this.editStyle},initFieldAccessors:function(a){a=[].concat(a);var d=this,g,e=a.length,b;for(g=0;g<e;g++){b=a[g];Ext.applyIf(b,{getEditor:function(c,h){return d.getColumnField(this,h)},setEditor:function(c){d.setColumnField(this,c)}})}},removeFieldAccessors:function(a){a=[].concat(a);var e,d=a.length,b;for(e=0;e<d;e++){b=a[e];delete b.getEditor;delete b.setEditor}},getColumnField:function(b,a){var c=b.field;if(!c&&b.editor){c=b.editor;delete b.editor}if(!c&&a){c=a}if(c){if(Ext.isString(c)){c={xtype:c}}if(!c.isFormField){c=Ext.ComponentManager.create(c,this.defaultFieldXType)}b.field=c;Ext.apply(c,{name:b.dataIndex});return c}},setColumnField:function(a,b){if(Ext.isObject(b)&&!b.isFormField){b=Ext.ComponentManager.create(b,this.defaultFieldXType)}a.field=b},initEvents:function(){var a=this;a.initEditTriggers();a.initCancelTriggers()},initCancelTriggers:Ext.emptyFn,initEditTriggers:function(){var b=this,a=b.view;if(b.triggerEvent=="cellfocus"){b.mon(a,"cellfocus",b.onCellFocus,b)}else{if(b.triggerEvent=="rowfocus"){b.mon(a,"rowfocus",b.onRowFocus,b)}else{if(a.selModel.isCellModel){a.onCellFocus=Ext.Function.bind(b.beforeViewCellFocus,b)}b.mon(a,b.triggerEvent||("cell"+(b.clicksToEdit===1?"click":"dblclick")),b.onCellClick,b)}}b.initAddRemoveHeaderEvents();a.on("render",b.initKeyNavHeaderEvents,b,{single:true})},beforeViewCellFocus:function(a){if(this.view.selModel.keyNavigation||!this.editing||!this.isCellEditable||!this.isCellEditable(a.row,a.columnHeader)){this.view.focusCell.apply(this.view,arguments)}},onRowFocus:function(a,c,b){this.startEdit(c,0)},onCellFocus:function(c,b,a){this.startEdit(a.row,a.column)},onCellClick:function(c,a,i,b,h,d,g){if(!c.expanderSelector||!g.getTarget(c.expanderSelector)){this.startEdit(b,c.getHeaderAtIndex(i))}},initAddRemoveHeaderEvents:function(){var a=this;a.mon(a.grid.headerCt,{scope:a,add:a.onColumnAdd,remove:a.onColumnRemove})},initKeyNavHeaderEvents:function(){var a=this;a.keyNav=Ext.create("Ext.util.KeyNav",a.view.el,{enter:a.onEnterKey,esc:a.onEscKey,scope:a})},onColumnAdd:function(a,b){if(b.isHeader){this.initFieldAccessors(b)}},onColumnRemove:function(a,b){if(b.isHeader){this.removeFieldAccessors(b)}},onEnterKey:function(h){var d=this,c=d.grid,b=c.getSelectionModel(),a,i,g=c.headerCt.getHeaderAtIndex(0);if(b.getCurrentPosition){i=b.getCurrentPosition();if(i){a=c.store.getAt(i.row);g=c.headerCt.getHeaderAtIndex(i.column)}}else{a=b.getLastSelected()}if(a&&g){d.startEdit(a,g)}},onEscKey:function(a){this.cancelEdit()},beforeEdit:Ext.emptyFn,startEdit:function(a,d){var c=this,b=c.getEditingContext(a,d);if(b==null||c.beforeEdit(b)===false||c.fireEvent("beforeedit",c,b)===false||b.cancel||!c.grid.view.isVisible(true)){return false}c.context=b;c.editing=true},getEditingContext:function(b,h){var g=this,c=g.grid,a=c.getView(),e=a.getNode(b),d,i;if(!e){return}h=c.headerCt.getVisibleHeaderClosestToIndex(Ext.isNumber(h)?h:h.getIndex());if(!h){return}i=h.getIndex();if(Ext.isNumber(b)){d=b;b=a.getRecord(e)}else{d=a.indexOf(e)}return{grid:c,record:b,field:h.dataIndex,value:b.get(h.dataIndex),row:a.getNode(d),column:h,rowIdx:d,colIdx:i}},cancelEdit:function(){var a=this;a.editing=false;a.fireEvent("canceledit",a,a.context)},completeEdit:function(){var a=this;if(a.editing&&a.validateEdit()){a.fireEvent("edit",a,a.context)}delete a.context;a.editing=false},validateEdit:function(){var b=this,a=b.context;return b.fireEvent("validateedit",b,a)!==false&&!a.cancel}});Ext.define("Ext.grid.plugin.CellEditing",{alias:"plugin.cellediting",extend:"Ext.grid.plugin.Editing",requires:["Ext.grid.CellEditor","Ext.util.DelayedTask"],constructor:function(){this.callParent(arguments);this.editors=new Ext.util.MixedCollection(false,function(a){return a.editorId});this.editTask=new Ext.util.DelayedTask()},onReconfigure:function(){this.editors.clear();this.callParent()},destroy:function(){var a=this;a.editTask.cancel();a.editors.each(Ext.destroy,Ext);a.editors.clear();a.callParent(arguments)},onBodyScroll:function(){var c=this,b=c.getActiveEditor(),a=c.view.el.getScroll();if(b&&b.editing){if(a.top!==c.scroll.top){if(b.field){if(b.field.triggerBlur){b.field.triggerBlur()}else{b.field.blur()}}}else{b.realign()}}c.scroll=a},initCancelTriggers:function(){var c=this,b=c.grid,a=b.view;a.addElListener("mousewheel",c.cancelEdit,c);c.mon(a,"bodyscroll",c.onBodyScroll,c);c.mon(b,{columnresize:c.cancelEdit,columnmove:c.cancelEdit,scope:c})},isCellEditable:function(a,d){var c=this,b=c.getEditingContext(a,d);if(c.grid.view.isVisible(true)&&b){d=b.column;a=b.record;if(d&&c.getEditor(a,d)){return true}}},startEdit:function(a,g){var d=this,c=d.getEditingContext(a,g),e,b;d.completeEdit();if(!c||!d.grid.view.isVisible(true)){return false}a=c.record;g=c.column;if(g&&!g.getEditor(a)){return false}e=a.get(g.dataIndex);c.originalValue=c.value=e;if(d.beforeEdit(c)===false||d.fireEvent("beforeedit",d,c)===false||c.cancel){return false}b=d.getEditor(a,g);d.grid.view.cancelFocus();d.view.focusCell({row:c.rowIdx,column:c.colIdx});if(b){d.editTask.delay(15,d.showEditor,d,[b,c,e]);return true}return false},showEditor:function(b,c,h){var e=this,a=c.record,g=c.column,i=e.grid.getSelectionModel(),d=i.getCurrentPosition();e.context=c;e.setActiveEditor(b);e.setActiveRecord(a);e.setActiveColumn(g);if(i.selectByPosition&&(!d||d.column!==c.colIdx||d.row!==c.rowIdx)){i.selectByPosition({row:c.rowIdx,column:c.colIdx})}b.startEdit(e.getCell(a,g),h);e.editing=true;e.scroll=e.view.el.getScroll()},completeEdit:function(){var a=this.getActiveEditor();if(a){a.completeEdit();this.editing=false}},setActiveEditor:function(a){this.activeEditor=a},getActiveEditor:function(){return this.activeEditor},setActiveColumn:function(a){this.activeColumn=a},getActiveColumn:function(){return this.activeColumn},setActiveRecord:function(a){this.activeRecord=a},getActiveRecord:function(){return this.activeRecord},getEditor:function(a,d){var g=this,e=g.editors,c=d.getItemId(),b=e.getByKey(c);if(b){return b}else{b=d.getEditor(a);if(!b){return false}if(!(b instanceof Ext.grid.CellEditor)){b=new Ext.grid.CellEditor({editorId:c,field:b,ownerCt:g.grid})}else{b.ownerCt=g.grid}b.editingPlugin=g;b.isForTree=g.grid.isTree;b.on({scope:g,specialkey:g.onSpecialKey,complete:g.onEditComplete,canceledit:g.cancelEdit});e.add(b);return b}},setColumnField:function(b,c){var a=this.editors.getByKey(b.getItemId());Ext.destroy(a,b.field);this.editors.removeAtKey(b.getItemId());this.callParent(arguments)},getCell:function(a,b){return this.grid.getView().getCell(a,b)},onSpecialKey:function(a,g,d){var c=this,b=c.grid,h;if(d.getKey()===d.TAB){d.stopEvent();if(a){a.onEditorTab(d)}h=b.getSelectionModel();if(h.onEditorTab){h.onEditorTab(c,d)}}},onEditComplete:function(c,h,b){var g=this,d=g.grid,e=g.getActiveColumn(),i=d.getSelectionModel(),a;if(e){a=g.context.record;g.setActiveEditor(null);g.setActiveColumn(null);g.setActiveRecord(null);if(!g.validateEdit()){return}if(!a.isEqual(h,b)){a.set(e.dataIndex,h)}if(i.setCurrentPosition){i.setCurrentPosition(i.getCurrentPosition())}d.getView().getEl(e).focus();g.context.value=h;g.fireEvent("edit",g,g.context)}},cancelEdit:function(){var c=this,b=c.getActiveEditor(),a=c.grid.getView().getEl(c.getActiveColumn());c.setActiveEditor(null);c.setActiveColumn(null);c.setActiveRecord(null);if(b){b.cancelEdit();a.focus();c.callParent(arguments)}},startEditByPosition:function(a){a.column=this.view.getHeaderCt().getVisibleHeaderClosestToIndex(a.column).getIndex();return this.startEdit(a.row,a.column)}});Ext.define("Ext.grid.plugin.DragDrop",{extend:"Ext.AbstractPlugin",alias:"plugin.gridviewdragdrop",uses:["Ext.view.DragZone","Ext.grid.ViewDropZone"],dragText:"{0} selected row{1}",ddGroup:"GridDD",enableDrop:true,enableDrag:true,init:function(a){a.on("render",this.onViewRender,this,{single:true})},destroy:function(){Ext.destroy(this.dragZone,this.dropZone)},enable:function(){var a=this;if(a.dragZone){a.dragZone.unlock()}if(a.dropZone){a.dropZone.unlock()}a.callParent()},disable:function(){var a=this;if(a.dragZone){a.dragZone.lock()}if(a.dropZone){a.dropZone.lock()}a.callParent()},onViewRender:function(a){var b=this;if(b.enableDrag){b.dragZone=new Ext.view.DragZone({view:a,ddGroup:b.dragGroup||b.ddGroup,dragText:b.dragText})}if(b.enableDrop){b.dropZone=new Ext.grid.ViewDropZone({view:a,ddGroup:b.dropGroup||b.ddGroup})}}});Ext.define("Ext.grid.plugin.RowEditing",{extend:"Ext.grid.plugin.Editing",alias:"plugin.rowediting",requires:["Ext.grid.RowEditor"],editStyle:"row",autoCancel:true,errorSummary:true,constructor:function(){var a=this;a.callParent(arguments);if(!a.clicksToMoveEditor){a.clicksToMoveEditor=a.clicksToEdit}a.autoCancel=!!a.autoCancel},init:function(a){this.callParent([a])},destroy:function(){var a=this;Ext.destroy(a.editor);a.callParent(arguments)},startEdit:function(a,d){var c=this,b=c.getEditor();if((b.beforeEdit()!==false)&&(c.callParent(arguments)!==false)){b.startEdit(c.context.record,c.context.column);return true}return false},cancelEdit:function(){var a=this;if(a.editing){a.getEditor().cancelEdit();a.callParent(arguments)}},completeEdit:function(){var a=this;if(a.editing&&a.validateEdit()){a.editing=false;a.fireEvent("edit",a,a.context)}},validateEdit:function(){var k=this,h=k.editor,b=k.context,g=b.record,m={},d={},j=h.items.items,i,c=j.length,a,l;for(i=0;i<c;i++){l=j[i];a=l.name;m[a]=l.getValue();d[a]=g.get(a)}Ext.apply(b,{newValues:m,originalValues:d});return k.callParent(arguments)&&k.getEditor().completeEdit()},getEditor:function(){var a=this;if(!a.editor){a.editor=a.initEditor()}return a.editor},initEditor:function(){var h=this,c=h.grid,i=h.view,d=c.headerCt,e=["saveBtnText","cancelBtnText","errorsText","dirtyText"],j,a=e.length,g={autoCancel:h.autoCancel,errorSummary:h.errorSummary,fields:d.getGridColumns(),hidden:true,view:i,editingPlugin:h,renderTo:i.el},k;for(j=0;j<a;j++){k=e[j];if(Ext.isDefined(h[k])){g[k]=h[k]}}return Ext.create("Ext.grid.RowEditor",g)},initEditTriggers:function(){var b=this,a=b.view,c=b.clicksToMoveEditor===1?"click":"dblclick";b.callParent(arguments);if(b.clicksToMoveEditor!==b.clicksToEdit){b.mon(a,"cell"+c,b.moveEditorByClick,b)}a.on({render:function(){b.mon(b.grid.headerCt,{scope:b,columnresize:b.onColumnResize,columnhide:b.onColumnHide,columnshow:b.onColumnShow,columnmove:b.onColumnMove})},single:true})},startEditByClick:function(){var a=this;if(!a.editing||a.clicksToMoveEditor===a.clicksToEdit){a.callParent(arguments)}},moveEditorByClick:function(){var a=this;if(a.editing){a.superclass.onCellClick.apply(a,arguments)}},onColumnAdd:function(a,c){if(c.isHeader){var d=this,b;d.initFieldAccessors(c);b=d.editor;if(b&&b.onColumnAdd){b.onColumnAdd(c)}}},onColumnRemove:function(a,c){if(c.isHeader){var d=this,b=d.getEditor();if(b&&b.onColumnRemove){b.onColumnRemove(c)}d.removeFieldAccessors(c)}},onColumnResize:function(a,d,c){if(d.isHeader){var e=this,b=e.getEditor();if(b&&b.onColumnResize){b.onColumnResize(d,c)}}},onColumnHide:function(a,c){var d=this,b=d.getEditor();if(b&&b.onColumnHide){b.onColumnHide(c)}},onColumnShow:function(a,c){var d=this,b=d.getEditor();if(b&&b.onColumnShow){b.onColumnShow(c)}},onColumnMove:function(a,d,c,g){var e=this,b=e.getEditor();if(b&&b.onColumnMove){b.onColumnMove(d,c,g-(g>c?1:0))}},setColumnField:function(b,d){var c=this,a=c.getEditor();a.removeField(b);c.callParent(arguments);c.getEditor().setField(b)}});Ext.define("Ext.grid.property.Grid",{extend:"Ext.grid.Panel",alias:"widget.propertygrid",alternateClassName:"Ext.grid.PropertyGrid",uses:["Ext.grid.plugin.CellEditing","Ext.grid.property.Store","Ext.grid.property.HeaderContainer","Ext.XTemplate","Ext.grid.CellEditor","Ext.form.field.Date","Ext.form.field.Text","Ext.form.field.Number","Ext.form.field.ComboBox"],valueField:"value",nameField:"name",enableColumnMove:false,columnLines:true,stripeRows:false,trackMouseOver:false,clicksToEdit:1,enableHdMenu:false,initComponent:function(){var a=this;a.addCls(Ext.baseCSSPrefix+"property-grid");a.plugins=a.plugins||[];a.plugins.push(new Ext.grid.plugin.CellEditing({clicksToEdit:a.clicksToEdit,startEdit:function(b,c){return this.self.prototype.startEdit.call(this,b,a.headerCt.child("#"+a.valueField))}}));a.selModel={selType:"cellmodel",onCellSelect:function(b){if(b.column!=1){b.column=1}return this.self.prototype.onCellSelect.call(this,b)}};a.customRenderers=a.customRenderers||{};a.customEditors=a.customEditors||{};if(!a.store){a.propStore=a.store=new Ext.grid.property.Store(a,a.source)}if(a.sortableColumns){a.store.sort("name","ASC")}a.columns=new Ext.grid.property.HeaderContainer(a,a.store);a.addEvents("beforepropertychange","propertychange");a.callParent();a.getView().walkCells=this.walkCells;a.editors={date:new Ext.grid.CellEditor({field:new Ext.form.field.Date({selectOnFocus:true})}),string:new Ext.grid.CellEditor({field:new Ext.form.field.Text({selectOnFocus:true})}),number:new Ext.grid.CellEditor({field:new Ext.form.field.Number({selectOnFocus:true})}),"boolean":new Ext.grid.CellEditor({field:new Ext.form.field.ComboBox({editable:false,store:[[true,a.headerCt.trueText],[false,a.headerCt.falseText]]})})};a.store.on("update",a.onUpdate,a)},onUpdate:function(d,a,c){var g=this,b,e;if(g.rendered&&c==Ext.data.Model.EDIT){b=a.get(g.valueField);e=a.modified.value;if(g.fireEvent("beforepropertychange",g.source,a.getId(),b,e)!==false){if(g.source){g.source[a.getId()]=b}a.commit();g.fireEvent("propertychange",g.source,a.getId(),b,e)}else{a.reject()}}},walkCells:function(h,g,d,c,a,b){if(g=="left"){g="up"}else{if(g=="right"){g="down"}}h=Ext.view.Table.prototype.walkCells.call(this,h,g,d,c,a,b);if(!h.column){h.column=1}return h},getCellEditor:function(a,c){var d=this,e=a.get(d.nameField),g=a.get(d.valueField),b=d.customEditors[e];if(b){if(!(b instanceof Ext.grid.CellEditor)){if(!(b instanceof Ext.form.field.Base)){b=Ext.ComponentManager.create(b,"textfield")}b=d.customEditors[e]=new Ext.grid.CellEditor({field:b})}}else{if(Ext.isDate(g)){b=d.editors.date}else{if(Ext.isNumber(g)){b=d.editors.number}else{if(Ext.isBoolean(g)){b=d.editors["boolean"]}else{b=d.editors.string}}}}b.editorId=e;return b},beforeDestroy:function(){var a=this;a.callParent();a.destroyEditors(a.editors);a.destroyEditors(a.customEditors);delete a.source},destroyEditors:function(b){for(var a in b){if(b.hasOwnProperty(a)){Ext.destroy(b[a])}}},setSource:function(a){this.source=a;this.propStore.setSource(a)},getSource:function(){return this.propStore.getSource()},setProperty:function(c,b,a){this.propStore.setValue(c,b,a)},removeProperty:function(a){this.propStore.remove(a)}});Ext.define("Ext.grid.property.HeaderContainer",{extend:"Ext.grid.header.Container",alternateClassName:"Ext.grid.PropertyColumnModel",nameWidth:115,nameText:"Name",valueText:"Value",dateFormat:"m/j/Y",trueText:"true",falseText:"false",nameColumnCls:Ext.baseCSSPrefix+"grid-property-name",constructor:function(b,a){var c=this;c.grid=b;c.store=a;c.callParent([{items:[{header:c.nameText,width:b.nameColumnWidth||c.nameWidth,sortable:b.sortableColumns,dataIndex:b.nameField,renderer:Ext.Function.bind(c.renderProp,c),itemId:b.nameField,menuDisabled:true,tdCls:c.nameColumnCls},{header:c.valueText,renderer:Ext.Function.bind(c.renderCell,c),getEditor:Ext.Function.bind(c.getCellEditor,c),sortable:b.sortableColumns,flex:1,fixed:true,dataIndex:b.valueField,itemId:b.valueField,menuDisabled:true}]}])},getCellEditor:function(a){return this.grid.getCellEditor(a,this)},renderProp:function(a){return this.getPropertyName(a)},renderCell:function(g,d,e){var b=this,c=b.grid.customRenderers[e.get(b.grid.nameField)],a=g;if(c){return c.apply(b,arguments)}if(Ext.isDate(g)){a=b.renderDate(g)}else{if(Ext.isBoolean(g)){a=b.renderBool(g)}}return Ext.util.Format.htmlEncode(a)},renderDate:Ext.util.Format.date,renderBool:function(a){return this[a?"trueText":"falseText"]},getPropertyName:function(b){var a=this.grid.propertyNames;return a&&a[b]?a[b]:b}});Ext.define("Ext.grid.property.Property",{extend:"Ext.data.Model",alternateClassName:"Ext.PropGridProperty",fields:[{name:"name",type:"string"},{name:"value"}],idProperty:"name"});Ext.define("Ext.grid.property.Store",{extend:"Ext.data.Store",alternateClassName:"Ext.grid.PropertyStore",sortOnLoad:false,uses:["Ext.data.reader.Reader","Ext.data.proxy.Proxy","Ext.data.ResultSet","Ext.grid.property.Property"],constructor:function(a,c){var b=this;b.grid=a;b.source=c;b.callParent([{data:c,model:Ext.grid.property.Property,proxy:b.getProxy()}])},getProxy:function(){if(!this.proxy){Ext.grid.property.Store.prototype.proxy=new Ext.data.proxy.Memory({model:Ext.grid.property.Property,reader:this.getReader()})}return this.proxy},getReader:function(){if(!this.reader){Ext.grid.property.Store.prototype.reader=new Ext.data.reader.Reader({model:Ext.grid.property.Property,buildExtractors:Ext.emptyFn,read:function(a){return this.readRecords(a)},readRecords:function(b){var d,c,a={records:[],success:true};for(c in b){if(b.hasOwnProperty(c)){d=b[c];if(this.isEditableValue(d)){a.records.push(new Ext.grid.property.Property({name:c,value:d},c))}}}a.total=a.count=a.records.length;return new Ext.data.ResultSet(a)},isEditableValue:function(a){return Ext.isPrimitive(a)||Ext.isDate(a)}})}return this.reader},setSource:function(a){var b=this;b.source=a;b.suspendEvents();b.removeAll();b.proxy.data=a;b.load();b.resumeEvents();b.fireEvent("datachanged",b);b.fireEvent("refresh",b)},getProperty:function(a){return Ext.isNumber(a)?this.getAt(a):this.getById(a)},setValue:function(e,c,a){var b=this,d=b.getRec(e);if(d){d.set("value",c);b.source[e]=c}else{if(a){b.source[e]=c;d=new Ext.grid.property.Property({name:e,value:c},e);b.add(d)}}},remove:function(b){var a=this.getRec(b);if(a){this.callParent([a]);delete this.source[b]}},getRec:function(a){return this.getById(a)},getSource:function(){return this.source}});Ext.define("Ext.layout.ClassList",(function(){var b=Ext.String.splitWords,a=Ext.Array.toMap;return{dirty:false,constructor:function(c){this.owner=c;this.map=a(this.classes=b(c.el.className))},add:function(c){var d=this;if(!d.map[c]){d.map[c]=true;d.classes.push(c);if(!d.dirty){d.dirty=true;d.owner.markDirty()}}},addMany:function(c){Ext.each(b(c),this.add,this)},contains:function(c){return this.map[c]},flush:function(){this.owner.el.className=this.classes.join(" ");this.dirty=false},remove:function(c){var d=this;if(d.map[c]){delete d.map[c];d.classes=Ext.Array.filter(d.classes,function(e){return e!=c});if(!d.dirty){d.dirty=true;d.owner.markDirty()}}},removeMany:function(d){var e=this,c=a(b(d));e.classes=Ext.Array.filter(e.classes,function(g){if(!c[g]){return true}delete e.map[g];if(!e.dirty){e.dirty=true;e.owner.markDirty()}return false})}}}()));Ext.define("Ext.util.Queue",{constructor:function(){this.clear()},add:function(c){var b=this,a=b.getKey(c);if(!b.map[a]){++b.length;b.items.push(c);b.map[a]=c}return c},clear:function(){var b=this,a=b.items;b.items=[];b.map={};b.length=0;return a},contains:function(b){var a=this.getKey(b);return this.map.hasOwnProperty(a)},getCount:function(){return this.length},getKey:function(a){return a.id},remove:function(e){var d=this,c=d.getKey(e),a=d.items,b;if(d.map[c]){b=Ext.Array.indexOf(a,e);Ext.Array.erase(a,b,1);delete d.map[c];--d.length}return e}});Ext.define("Ext.layout.ContextItem",{requires:["Ext.layout.ClassList"],heightModel:null,widthModel:null,sizeModel:null,boxChildren:null,boxParent:null,children:[],dirty:null,dirtyCount:0,hasRawContent:true,isContextItem:true,isTopLevel:false,consumersContentHeight:0,consumersContentWidth:0,consumersContainerHeight:0,consumersContainerWidth:0,consumersHeight:0,consumersWidth:0,ownerCtContext:null,remainingChildLayouts:0,remainingComponentChildLayouts:0,remainingContainerChildLayouts:0,props:null,state:null,wrapsComponent:false,constructor:function(b){var g=this,e,d,a,c,h;Ext.apply(g,b);e=g.el;g.id=e.id;g.lastBox=e.lastBox;g.flushedProps={};g.props={};g.styles={};h=g.target;if(h.isComponent){g.wrapsComponent=true;d=h.ownerCt;if(d&&(a=g.context.items[d.el.id])){g.ownerCtContext=a}g.sizeModel=c=h.getSizeModel(a&&a.widthModel.pairsByHeightOrdinal[a.heightModel.ordinal]);g.widthModel=c.width;g.heightModel=c.height}},init:function(j,c){var s=this,a=s.props,d=s.dirty,l=s.ownerCtContext,p=s.target.ownerLayout,h=!s.state,t=j||h,e,o,m,q,b,u,v=s.heightModel,g=s.widthModel,k,r;s.dirty=s.invalid=false;s.props={};if(s.boxChildren){s.boxChildren.length=0}if(!h){s.clearAllBlocks("blocks");s.clearAllBlocks("domBlocks")}if(!s.wrapsComponent){return t}u=s.target;s.state={};if(h){if(u.beforeLayout){u.beforeLayout()}if(!l&&(q=u.ownerCt)){l=s.context.items[q.el.id]}if(l){s.ownerCtContext=l;s.isBoxParent=u.ownerLayout.isItemBoxParent(s)}else{s.isTopLevel=true}s.frameBodyContext=s.getEl("frameBody")}else{l=s.ownerCtContext;s.isTopLevel=!l;e=s.children;for(o=0,m=e.length;o<m;++o){e[o].init(true)}}s.hasRawContent=!(u.isContainer&&u.items.items.length>0);if(j){s.widthModel=s.heightModel=null;b=u.getSizeModel(l&&l.widthModel.pairsByHeightOrdinal[l.heightModel.ordinal]);if(h){s.sizeModel=b}s.widthModel=b.width;s.heightModel=b.height}else{if(a){s.recoverProp("x",a,d);s.recoverProp("y",a,d);if(s.widthModel.calculated){s.recoverProp("width",a,d)}if(s.heightModel.calculated){s.recoverProp("height",a,d)}}}if(a&&p&&p.manageMargins){s.recoverProp("margin-top",a,d);s.recoverProp("margin-right",a,d);s.recoverProp("margin-bottom",a,d);s.recoverProp("margin-left",a,d)}if(c){k=c.heightModel;r=c.widthModel;if(r&&k&&g&&v){if(g.shrinkWrap&&v.shrinkWrap){if(r.constrainedMax&&k.constrainedMin){k=null}}}if(r){s.widthModel=r}if(k){s.heightModel=k}if(c.state){Ext.apply(s.state,c.state)}}return t},initContinue:function(d){var e=this,c=e.ownerCtContext,b=e.widthModel,a;if(d){if(c&&b.shrinkWrap){a=c.isBoxParent?c:c.boxParent;if(a){a.addBoxChild(e)}}else{if(b.natural){e.boxParent=c}}}return d},initDone:function(b,g,a,h){var d=this,c=d.props,e=d.state;if(g){c.componentChildrenDone=true}if(a){c.containerChildrenDone=true}if(h){c.containerLayoutDone=true}if(d.boxChildren&&d.boxChildren.length&&d.widthModel.shrinkWrap){d.el.setWidth(10000);e.blocks=(e.blocks||0)+1}},initAnimation:function(){var b=this,c=b.target,a=b.ownerCtContext;if(a&&a.isTopLevel){b.animatePolicy=c.ownerLayout.getAnimatePolicy(b)}else{if(!a&&c.isCollapsingOrExpanding&&c.animCollapse){b.animatePolicy=c.componentLayout.getAnimatePolicy(b)}}if(b.animatePolicy){b.context.queueAnimation(b)}},noFraming:{left:0,top:0,right:0,bottom:0,width:0,height:0},addCls:function(a){this.getClassList().addMany(a)},removeCls:function(a){this.getClassList().removeMany(a)},addBlock:function(b,d,e){var c=this,g=c[b]||(c[b]={}),a=g[e]||(g[e]={});if(!a[d.id]){a[d.id]=d;++d.blockCount;++c.context.blockCount}},addBoxChild:function(d){var c=this,b,a=d.widthModel;d.boxParent=this;d.measuresBox=a.shrinkWrap?d.hasRawContent:a.natural;if(d.measuresBox){b=c.boxChildren;if(b){b.push(d)}else{c.boxChildren=[d]}}},addTrigger:function(g,h){var e=this,a=h?"domTriggers":"triggers",i=e[a]||(e[a]={}),b=e.context,d=b.currentLayout,c=i[g]||(i[g]={});if(!c[d.id]){c[d.id]=d;++d.triggerCount;c=b.triggers[h?"dom":"data"];(c[d.id]||(c[d.id]=[])).push({item:this,prop:g});if(e.props[g]!==undefined){if(!h||!(e.dirty&&(g in e.dirty))){++d.firedTriggers}}}},boxChildMeasured:function(){var b=this,c=b.state,a=(c.boxesMeasured=(c.boxesMeasured||0)+1);if(a==b.boxChildren.length){c.clearBoxWidth=1;++b.context.progressCount;b.markDirty()}},borderNames:["border-top-width","border-right-width","border-bottom-width","border-left-width"],marginNames:["margin-top","margin-right","margin-bottom","margin-left"],paddingNames:["padding-top","padding-right","padding-bottom","padding-left"],trblNames:["top","right","bottom","left"],cacheMissHandlers:{borderInfo:function(a){var b=a.getStyles(a.borderNames,a.trblNames);b.width=b.left+b.right;b.height=b.top+b.bottom;return b},marginInfo:function(a){var b=a.getStyles(a.marginNames,a.trblNames);b.width=b.left+b.right;b.height=b.top+b.bottom;return b},paddingInfo:function(b){var a=b.frameBodyContext||b,c=a.getStyles(b.paddingNames,b.trblNames);c.width=c.left+c.right;c.height=c.top+c.bottom;return c}},checkCache:function(a){return this.cacheMissHandlers[a](this)},clearAllBlocks:function(a){var c=this[a],b;if(c){for(b in c){this.clearBlocks(a,b)}}},clearBlocks:function(c,g){var h=this[c],b=h&&h[g],d,e,a;if(b){delete h[g];d=this.context;for(a in b){e=b[a];--d.blockCount;if(!--e.blockCount&&!e.pending&&!e.done){d.queueLayout(e)}}}},block:function(a,b){this.addBlock("blocks",a,b)},domBlock:function(a,b){this.addBlock("domBlocks",a,b)},fireTriggers:function(b,g){var h=this[b],d=h&&h[g],c=this.context,e,a;if(d){for(a in d){e=d[a];++e.firedTriggers;if(!e.done&&!e.blockCount&&!e.pending){c.queueLayout(e)}}}},flush:function(){var b=this,a=b.dirty,c=b.state,d=b.el;b.dirtyCount=0;if(b.classList&&b.classList.dirty){b.classList.flush()}if("attributes" in b){d.set(b.attributes);delete b.attributes}if("innerHTML" in b){d.innerHTML=b.innerHTML;delete b.innerHTML}if(c&&c.clearBoxWidth){c.clearBoxWidth=0;b.el.setStyle("width",null);if(!--c.blocks){b.context.queueItemLayouts(b)}}if(a){delete b.dirty;b.writeProps(a,true)}},flushAnimations:function(){var o=this,c=o.lastBox,l,n,e,h,g,d,i,m,k,a,b;if(c){l=o.target;n=l.layout&&l.layout.animate;if(n){e=Ext.isNumber(n)?n:n.duration}h=Ext.Object.getKeys(o.animatePolicy);g=Ext.apply({},{from:{},to:{},duration:e||Ext.fx.Anim.prototype.duration},n);for(d=0,i=0,m=h.length;i<m;i++){k=h[i];a=c[k];b=o.peek(k);if(a!=b){k=o.translateProps[k]||k;g.from[k]=a;g.to[k]=b;++d}}if(d){if(o.isCollapsingOrExpanding===1){l.componentLayout.undoLayout(o)}else{o.writeProps(g.from)}o.el.animate(g);Ext.fx.Manager.getFxQueue(o.el.id)[0].on({afteranimate:function(){if(o.isCollapsingOrExpanding===1){l.componentLayout.redoLayout(o);l.afterCollapse(true)}else{if(o.isCollapsingOrExpanding===2){l.afterExpand(true)}}}})}}},getBorderInfo:function(){var a=this,b=a.borderInfo;if(!b){a.borderInfo=b=a.checkCache("borderInfo")}return b},getClassList:function(){return this.classList||(this.classList=new Ext.layout.ClassList(this))},getEl:function(c,a){var e=this,g,d,b;if(c){if(c.dom){d=c}else{g=e.target;if(a){g=a}d=g[c];if(typeof d=="function"){d=d.call(g);if(d===e.el){return this}}}if(d){b=e.context.getEl(e,d)}}return b||null},getFraming:function(){var a=this;if(!a.framingInfo){a.framingInfo=a.target.frameSize||a.noFraming}return a.framingInfo},getFrameInfo:function(){var b=this,c=b.frameInfo,d,a;if(!c){d=b.getFraming();a=b.getBorderInfo();b.frameInfo=c={top:d.top+a.top,right:d.right+a.right,bottom:d.bottom+a.bottom,left:d.left+a.left,width:d.width+a.width,height:d.height+a.height}}return c},getMarginInfo:function(){var d=this,h=d.marginInfo,b,a,g,e,c;if(!h){if(!d.wrapsComponent){h=d.checkCache("marginInfo")}else{b=d.target;e=b.ownerLayout;c=e?e.id:null;a=e&&e.manageMargins;h=b.margin$;if(h&&h.ownerId!==c){h=null}if(!h){h=d.parseMargins(b.margin)||d.checkCache("marginInfo");if(a){g=d.parseMargins(b.margins,e.defaultMargins);if(g){h={top:h.top+g.top,right:h.right+g.right,bottom:h.bottom+g.bottom,left:h.left+g.left}}d.setProp("margin-top",0);d.setProp("margin-right",0);d.setProp("margin-bottom",0);d.setProp("margin-left",0)}h.ownerId=c;b.margin$=h}h.width=h.left+h.right;h.height=h.top+h.bottom}d.marginInfo=h}return h},clearMarginCache:function(){delete this.marginInfo;delete this.target.margin$},getPaddingInfo:function(){var a=this,b=a.paddingInfo;if(!b){a.paddingInfo=b=a.checkCache("paddingInfo")}return b},getProp:function(c){var b=this,a=b.props[c];b.addTrigger(c);return a},getDomProp:function(c){var b=this,a=(b.dirty&&(c in b.dirty))?undefined:b.props[c];b.addTrigger(c,true);return a},getStyle:function(a){var c=this,b=c.styles,e,d;if(a in b){d=b[a]}else{e=c.styleInfo[a];d=c.el.getStyle(a);if(e&&e.parseInt){d=parseInt(d,10)||0}b[a]=d}return d},getStyles:function(p,b){var m=this,e=m.styles,q={},g=0,d=p.length,k,j,l,a,c,h,r,o;b=b||p;for(k=0;k<d;++k){a=p[k];if(a in e){q[b[k]]=e[a];++g;if(k&&g==1){j=p.slice(0,k);l=b.slice(0,k)}}else{if(g){(j||(j=[])).push(a);(l||(l=[])).push(b[k])}}}if(g<d){j=j||p;l=l||b;h=m.styleInfo;r=m.el.getStyle(j);for(k=j.length;k--;){a=j[k];c=h[a];o=r[a];if(c&&c.parseInt){o=parseInt(o,10)||0}q[l[k]]=o;e[a]=o}}return q},hasProp:function(b){var a=this.getProp(b);return typeof a!="undefined"},hasDomProp:function(b){var a=this.getDomProp(b);return typeof a!="undefined"},invalidate:function(a){this.context.queueInvalidate(this,a)},markDirty:function(){if(++this.dirtyCount==1){this.context.queueFlush(this)}},onBoxMeasured:function(){var a=this.boxParent,b=this.state;if(a&&a.widthModel.shrinkWrap&&!b.boxMeasured&&this.measuresBox){b.boxMeasured=1;a.boxChildMeasured()}},parseMargins:function(d,c){if(d===true){d=5}var b=typeof d,a;if(b=="string"||b=="number"){a=Ext.util.Format.parseBox(d)}else{if(d||c){a={top:0,right:0,bottom:0,left:0};if(c){Ext.apply(a,this.parseMargins(c))}Ext.apply(a,d)}}return a},peek:function(a){return this.props[a]},recoverProp:function(g,b,a){var e=this,d=e.props,c;if(g in b){d[g]=b[g];if(a&&g in a){c=e.dirty||(e.dirty={});c[g]=a[g]}}},redo:function(b){var e=this,c,a,d;e.revertProps(e.props);if(b&&e.wrapsComponent){if(e.childItems){for(d=0,c=e.childItems,a=c.length;d<a;d++){c[d].redo(b)}}for(d=0,c=e.children,a=c.length;d<a;d++){c[d].redo()}}},revertProps:function(d){var a,b=this.flushedProps,c={};for(a in d){if(b.hasOwnProperty(a)){c[a]=d[a]}}this.writeProps(c)},setAttribute:function(a,c){var b=this;if(!b.attributes){b.attributes={}}b.attributes[a]=c;b.markDirty()},setBox:function(b){var a=this;if("left" in b){a.setProp("x",b.left)}if("top" in b){a.setProp("y",b.top)}a.setSize(b.width,b.height)},setContentHeight:function(a,b){if(!b&&this.hasRawContent){return 1}return this.setProp("contentHeight",a)},setContentWidth:function(b,a){if(!a&&this.hasRawContent){return 1}return this.setProp("contentWidth",b)},setContentSize:function(c,a,b){return this.setContentWidth(c,b)+this.setContentHeight(a,b)==2},setProp:function(d,c,a){var b=this,h=typeof c,g,e;if(h=="undefined"||(h==="number"&&isNaN(c))){return 0}if(b.props[d]===c){return 1}b.props[d]=c;++b.context.progressCount;if(a===false){b.fireTriggers("domTriggers",d);b.clearBlocks("domBlocks",d)}else{e=b.styleInfo[d];if(e){if(!b.dirty){b.dirty={}}if(d=="width"||d=="height"){g=b.isBorderBoxValue;if(g==null){b.isBorderBoxValue=g=!!b.el.isBorderBox()}if(!g){b.borderInfo||b.getBorderInfo();b.paddingInfo||b.getPaddingInfo()}}b.dirty[d]=c;b.markDirty()}}b.fireTriggers("triggers",d);b.clearBlocks("blocks",d);return 1},setHeight:function(a,c){var e=this,b=e.target,h,d,g;if(a<0){a=0}if(!e.wrapsComponent){if(!e.setProp("height",a,c)){return NaN}}else{a=Ext.Number.constrain(a,b.minHeight||0,b.maxHeight);if(!e.setProp("height",a,c)){return NaN}h=e.frameBodyContext;if(h){d=e.getFrameInfo();h.setHeight(a-d.height,c)}}return a},setWidth:function(c,b){var e=this,a=e.target,h,d,g;if(c<0){c=0}if(!e.wrapsComponent){if(!e.setProp("width",c,b)){return NaN}}else{c=Ext.Number.constrain(c,a.minWidth||0,a.maxWidth);if(!e.setProp("width",c,b)){return NaN}h=e.frameBodyContext;if(h){d=e.getFrameInfo();h.setWidth(c-d.width,b)}}return c},setSize:function(c,a,b){this.setWidth(c,b);this.setHeight(a,b)},translateProps:{x:"left",y:"top"},undo:function(b){var e=this,c,a,d;e.revertProps(e.lastBox);if(b&&e.wrapsComponent){if(e.childItems){for(d=0,c=e.childItems,a=c.length;d<a;d++){c[d].undo(b)}}for(d=0,c=e.children,a=c.length;d<a;d++){c[d].undo()}}},unsetProp:function(b){var a=this.dirty;delete this.props[b];if(a){delete a[b]}},writeProps:function(e,d){if(!(e&&typeof e=="object")){return}var C=this,c=C.el,i={},h=0,b=C.styleInfo,B,n,r,m="x" in e,l="y" in e,k=e.x,j=e.y,t=e.width,p=e.height,A=C.isBorderBoxValue,D=C.target,v=Math.max,z=0,o=0,g,a,s,u,w,q;if("displayed" in e){c.setDisplayed(e.displayed)}for(n in e){if(d){C.fireTriggers("domTriggers",n);C.clearBlocks("domBlocks",n);C.flushedProps[n]=1}B=b[n];if(B&&B.dom){if(B.suffix&&(r=parseInt(e[n],10))){i[n]=r+B.suffix}else{i[n]=e[n]}++h}}if(m||l){if(D.isComponent){D.setPosition(k||C.props.x,j||C.props.y)}else{if(m){i.left=k+"px";++h}if(l){i.top=j+"px";++h}}}if(!A&&(t>0||p>0)){if(!C.frameBodyContext){z=C.paddingInfo.width;o=C.paddingInfo.height}if(t){t=v(parseInt(t,10)-(C.borderInfo.width+z),0);i.width=t+"px";++h}if(p){p=v(parseInt(p,10)-(C.borderInfo.height+o),0);i.height=p+"px";++h}}if(C.wrapsComponent&&Ext.isIE9&&Ext.isStrict){if((g=t!==undefined&&C.hasOverflowY)||(a=p!==undefined&&C.hasOverflowX)){s=C.isAbsolute;if(s===undefined){s=false;q=C.target.getTargetEl();w=q.getStyle("position");if(w=="absolute"){w=q.getStyle("box-sizing");s=(w=="border-box")}C.isAbsolute=s}if(s){u=Ext.getScrollbarSize();if(g){t=parseInt(t,10)+u.width;i.width=t+"px";++h}if(a){p=parseInt(p,10)+u.height;i.height=p+"px";++h}}}}if(h){c.setStyle(i)}}},function(){var c={dom:true,parseInt:true,suffix:"px"},b={dom:true},a={dom:false};this.prototype.styleInfo={childrenDone:a,componentChildrenDone:a,containerChildrenDone:a,containerLayoutDone:a,displayed:a,done:a,x:a,y:a,columnWidthsDone:a,left:c,top:c,right:c,bottom:c,width:c,height:c,"border-top-width":c,"border-right-width":c,"border-bottom-width":c,"border-left-width":c,"margin-top":c,"margin-right":c,"margin-bottom":c,"margin-left":c,"padding-top":c,"padding-right":c,"padding-bottom":c,"padding-left":c,"line-height":b,display:b}});Ext.define("Ext.layout.Context",{requires:["Ext.util.Queue","Ext.layout.ContextItem","Ext.layout.Layout","Ext.fx.Anim","Ext.fx.Manager"],remainingLayouts:0,state:0,constructor:function(a){var b=this;Ext.apply(b,a);b.items={};b.layouts={};b.blockCount=0;b.cycleCount=0;b.flushCount=0;b.calcCount=0;b.animateQueue=b.newQueue();b.completionQueue=b.newQueue();b.finalizeQueue=b.newQueue();b.finishQueue=b.newQueue();b.flushQueue=b.newQueue();b.invalidateData={};b.layoutQueue=b.newQueue();b.invalidQueue=[];b.triggers={data:{},dom:{}}},callLayout:function(b,a){this.currentLayout=b;b[a](this.getCmp(b.owner))},cancelComponent:function(j,a,m){var p=this,h=j,l=!j.isComponent,b=l?h.length:1,d,c,o,n,g,s,q,r,t,e;for(d=0;d<b;++d){if(l){j=h[d]}if(m&&j.ownerCt){e=this.items[j.ownerCt.el.id];if(e){Ext.Array.remove(e.childItems,p.getCmp(j))}}if(!a){q=p.invalidQueue;o=q.length;if(o){p.invalidQueue=s=[];for(c=0;c<o;++c){r=q[c];t=r.item.target;if(t!=j&&!t.isDescendant(j)){s.push(r)}}}}g=j.componentLayout;p.cancelLayout(g);if(g.getLayoutItems){n=g.getLayoutItems();if(n.length){p.cancelComponent(n,true)}}if(j.isContainer&&!j.collapsed){g=j.layout;p.cancelLayout(g);n=g.getVisibleItems();if(n.length){p.cancelComponent(n,true)}}}},cancelLayout:function(b){var a=this;a.completionQueue.remove(b);a.finalizeQueue.remove(b);a.finishQueue.remove(b);a.layoutQueue.remove(b);if(b.running){a.layoutDone(b)}b.ownerContext=null},clearTriggers:function(g,h){var a=g.id,e=this.triggers[h?"dom":"data"],j=e&&e[a],b=(j&&j.length)||0,e,d,k,c;for(d=0;d<b;++d){c=j[d];k=c.item;e=h?k.domTriggers:k.triggers;delete e[c.prop][a]}},flush:function(){var d=this,a=d.flushQueue.clear(),c=a.length,b;if(c){++d.flushCount;for(b=0;b<c;++b){a[b].flush()}}},flushAnimations:function(){var d=this,b=d.animateQueue.clear(),a=b.length,c;if(a){for(c=0;c<a;c++){if(b[c].target.animate!==false){b[c].flushAnimations()}}Ext.fx.Manager.runner()}},flushInvalidates:function(){var h=this,a=h.invalidQueue,g=a&&a.length,b,e,d,c;h.invalidQueue=[];if(g){e=[];for(c=0;c<g;++c){b=(d=a[c]).item.target;if(!b.container.isDetachedBody){e.push(b);if(d.options){h.invalidateData[b.id]=d.options}}}h.invalidate(e,null)}},flushLayouts:function(h,a,c){var g=this,j=c?g[h].items:g[h].clear(),e=j.length,b,d;if(e){for(b=0;b<e;++b){d=j[b];if(!d.running){g.callLayout(d,a)}}g.currentLayout=null}},getCmp:function(a){return this.getItem(a,a.el)},getEl:function(b,a){var c=this.getItem(a,a);if(!c.parent){c.parent=b;if(b.children.length){b.children.push(c)}else{b.children=[c]}}return c},getItem:function(d,b){var e=b.id,a=this.items,c=a[e]||(a[e]=new Ext.layout.ContextItem({context:this,target:d,el:b}));return c},handleFailure:function(){var c=this.layouts,b,a;Ext.failedLayouts=(Ext.failedLayouts||0)+1;for(a in c){b=c[a];if(c.hasOwnProperty(a)){b.running=false;b.ownerContext=null}}},invalidate:function(n,p){var r=this,o=!n.isComponent,e,g,c,a,j,m,s,q,b,k,l,h,d;for(j=0,b=o?n.length:1;j<b;++j){m=o?n[j]:n;if(m.rendered&&!m.hidden){s=r.getCmp(m);k=m.componentLayout;a=!k.ownerContext;l=(m.isContainer&&!m.collapsed)?m.layout:null;h=r.invalidateData[s.id];delete r.invalidateData[s.id];d=s.init(p,h);if(h){r.processInvalidate(h,s,"before")}if(k.beforeLayoutCycle){k.beforeLayoutCycle(s)}d=s.initContinue(d);e=g=c=true;if(k.getLayoutItems){k.renderChildren();q=k.getLayoutItems();if(q.length){r.invalidate(q,true);e=false}}if(l){c=false;l.renderChildren();q=l.getVisibleItems();if(q.length){r.invalidate(q,true);g=false}}s.initDone(d,e,g,c);r.resetLayout(k,s,a);if(l){r.resetLayout(l,s,a)}s.initAnimation();if(h){r.processInvalidate(h,s,"after")}}}r.currentLayout=null},layoutDone:function(b){var c=b.ownerContext,a;b.running=false;if(b.isComponentLayout){if(c.measuresBox){c.onBoxMeasured()}c.setProp("done",true);a=c.ownerCtContext;if(a){if(c.target.ownerLayout.isComponentLayout){if(!--a.remainingComponentChildLayouts){a.setProp("componentChildrenDone",true)}}else{if(!--a.remainingContainerChildLayouts){a.setProp("containerChildrenDone",true)}}if(!--a.remainingChildLayouts){a.setProp("childrenDone",true)}}}else{c.setProp("containerLayoutDone",true)}--this.remainingLayouts;++this.progressCount},newQueue:function(){return new Ext.util.Queue()},processInvalidate:function(b,e,a){if(b[a]){var d=this,c=d.currentLayout;d.currentLayout=b.layout||null;b[a](e,b);d.currentLayout=c}},queueAnimation:function(a){this.animateQueue.add(a)},queueCompletion:function(a){this.completionQueue.add(a)},queueFinalize:function(a){this.finalizeQueue.add(a)},queueFlush:function(a){this.flushQueue.add(a)},chainFns:function(a,i,g){var d=this,c=a.layout,e=i.layout,b=a[g],h=i[g];return function(j){var k=d.currentLayout;if(b){d.currentLayout=c;b.call(a.scope||a,j,a)}d.currentLayout=e;h.call(i.scope||i,j,i);d.currentLayout=k}},queueInvalidate:function(k,l){var h=this,j=[],i=h.invalidQueue,g=i.length,d,b,e,a,c;if(k.isComponent){k=h.getCmp(d=k)}else{d=k.target}k.invalid=true;while(g--){b=i[g];e=b.item.target;if(d.isDescendant(e)){return}if(e==d){if(!(a=b.options)){b.options=l}else{if(l){if(l.widthModel){a.widthModel=l.widthModel}if(l.heightModel){a.heightModel=l.heightModel}if(!(c=a.state)){a.state=l.state}else{if(l.state){Ext.apply(c,l.state)}}if(l.before){a.before=h.chainFns(a,l,"before")}if(l.after){a.after=h.chainFns(a,l,"after")}}}return}if(!e.isDescendant(d)){j.push(b)}}j.push({item:k,options:l});h.invalidQueue=j},queueItemLayouts:function(c){var a=c.isComponent?c:c.target,b=a.componentLayout;if(!b.pending&&!b.invalid&&!b.done){this.queueLayout(b)}b=a.layout;if(b&&!b.pending&&!b.invalid&&!b.done){this.queueLayout(b)}},queueLayout:function(a){this.layoutQueue.add(a);a.pending=true},resetLayout:function(c,d,e){var b=this,a;b.currentLayout=c;c.done=false;c.pending=true;c.firedTriggers=0;b.layoutQueue.add(c);if(e){b.layouts[c.id]=c;c.running=true;if(c.finishedLayout){b.finishQueue.add(c)}++b.remainingLayouts;++c.layoutCount;c.ownerContext=d;c.beginCount=0;c.blockCount=0;c.calcCount=0;c.triggerCount=0;if(c.isComponentLayout&&(a=d.ownerCtContext)){if(d.target.ownerLayout.isComponentLayout){++a.remainingComponentChildLayouts}else{++a.remainingContainerChildLayouts}++a.remainingChildLayouts}if(!c.initialized){c.initLayout()}c.beginLayout(d)}else{++c.beginCount;if(!c.running){++b.remainingLayouts;c.running=true;if(c.isComponentLayout){d.unsetProp("done");a=d.ownerCtContext;if(a){if(d.target.ownerLayout.isComponentLayout){if(++a.remainingComponentChildLayouts==1){a.unsetProp("componentChildrenDone")}}else{if(++a.remainingContainerChildLayouts==1){a.unsetProp("containerChildrenDone")}}if(++a.remainingChildLayouts==1){a.unsetProp("childrenDone")}}}b.completionQueue.remove(c);b.finalizeQueue.remove(c)}}c.beginLayoutCycle(d,e)},run:function(){var c=this,b=false,a=100;c.flushInvalidates();c.state=1;c.totalCount=c.layoutQueue.getCount();c.flush();while((c.remainingLayouts||c.invalidQueue.length)&&a--){if(c.invalidQueue.length){c.flushInvalidates()}if(c.runCycle()){b=false}else{if(!b){c.flush();b=true;c.flushLayouts("completionQueue","completeLayout")}else{c.state=2;break}}if(!(c.remainingLayouts||c.invalidQueue.length)){c.flush();c.flushLayouts("completionQueue","completeLayout");c.flushLayouts("finalizeQueue","finalizeLayout")}}return c.runComplete()},runComplete:function(){var a=this;a.state=2;if(a.remainingLayouts){a.handleFailure();return false}a.flush();a.flushLayouts("finishQueue","finishedLayout",true);a.flushLayouts("finishQueue","notifyOwner");a.flush();a.flushAnimations();return true},runCycle:function(){var c=this,d=c.layoutQueue.clear(),b=d.length,a;++c.cycleCount;c.progressCount=0;for(a=0;a<b;++a){c.runLayout(c.currentLayout=d[a])}c.currentLayout=null;return c.progressCount>0},runLayout:function(b){var a=this,c=a.getCmp(b.owner);b.pending=false;if(c.state.blocks){return}b.done=true;++b.calcCount;++a.calcCount;b.calculate(c);if(b.done){a.layoutDone(b);if(b.completeLayout){a.queueCompletion(b)}if(b.finalizeLayout){a.queueFinalize(b)}}else{if(!b.pending&&!b.invalid&&!(b.blockCount+b.triggerCount-b.firedTriggers)){a.queueLayout(b)}}},setItemSize:function(h,g,b){var d=h,a=1,c,e;if(h.isComposite){d=h.elements;a=d.length;h=d[0]}else{if(!h.dom&&!h.el){a=d.length;h=d[0]}}for(e=0;e<a;){c=this.get(h);c.setSize(g,b);h=d[++e]}}});Ext.define("Ext.layout.component.Tab",{extend:"Ext.layout.component.Button",alias:"layout.tab",beginLayout:function(c){var b=this,a=b.owner.closable;if(b.lastClosable!==a){b.lastClosable=a;b.clearTargetCache()}b.callParent(arguments)}});Ext.define("Ext.layout.component.field.Slider",{alias:["layout.sliderfield"],extend:"Ext.layout.component.field.Field",type:"sliderfield",beginLayout:function(a){this.callParent(arguments);a.endElContext=a.getEl("endEl");a.innerElContext=a.getEl("innerEl");a.bodyElContext=a.getEl("bodyEl")},publishInnerHeight:function(d,a){var e=a-this.measureLabelErrorHeight(d),c,b;if(this.owner.vertical){c=d.endElContext.getPaddingInfo();b=d.inputContext.getPaddingInfo();d.innerElContext.setHeight(e-b.height-c.height)}else{d.bodyElContext.setHeight(e)}},publishInnerWidth:function(d,c){if(!this.owner.vertical){var b=d.endElContext.getPaddingInfo(),a=d.inputContext.getPaddingInfo();d.innerElContext.setWidth(c-a.left-b.right-d.labelContext.getProp("width"))}},beginLayoutFixed:function(d,a,e){var b=this,c=b.ieInputWidthAdjustment;if(c){b.owner.bodyEl.setStyle("padding-right",c+"px")}b.callParent(arguments)}});Ext.define("Ext.layout.container.Absolute",{alias:"layout.absolute",extend:"Ext.layout.container.Anchor",alternateClassName:"Ext.layout.AbsoluteLayout",targetCls:Ext.baseCSSPrefix+"abs-layout-ct",itemCls:Ext.baseCSSPrefix+"abs-layout-item",ignoreOnContentChange:true,type:"absolute",adjustWidthAnchor:function(c,b){var d=this.targetPadding,a=b.getStyle("left");return c-a+d.left},adjustHeightAnchor:function(b,a){var c=this.targetPadding,d=a.getStyle("top");return b-d+c.top},isItemLayoutRoot:function(a){return this.ignoreOnContentChange||this.callParent(arguments)},isItemShrinkWrap:function(a){return true},beginLayout:function(b){var a=this,c=a.getTarget();a.callParent(arguments);if(c.dom!==document.body){c.position()}a.targetPadding=b.targetContext.getPaddingInfo()},isItemBoxParent:function(a){return true},onContentChange:function(){if(this.ignoreOnContentChange){return false}return this.callParent(arguments)}});Ext.define("Ext.layout.container.Accordion",{extend:"Ext.layout.container.VBox",alias:["layout.accordion"],alternateClassName:"Ext.layout.AccordionLayout",itemCls:[Ext.baseCSSPrefix+"box-item",Ext.baseCSSPrefix+"accordion-item"],align:"stretch",fill:true,titleCollapse:true,hideCollapseTool:false,collapseFirst:false,animate:true,activeOnTop:false,multi:false,defaultAnimatePolicy:{y:true,height:true},constructor:function(){var a=this;a.callParent(arguments);if(a.animate){a.animatePolicy=Ext.apply({},a.defaultAnimatePolicy)}else{a.animatePolicy=null}},beforeRenderItems:function(b){var e=this,d=b.length,c=0,a;for(;c<d;c++){a=b[c];if(!a.rendered){if(e.collapseFirst){a.collapseFirst=e.collapseFirst}if(e.hideCollapseTool){a.hideCollapseTool=e.hideCollapseTool;a.titleCollapse=true}else{if(e.titleCollapse){a.titleCollapse=e.titleCollapse}}delete a.hideHeader;delete a.width;a.collapsible=true;a.title=a.title||"&#160;";a.addBodyCls(Ext.baseCSSPrefix+"accordion-body");if(!e.multi){if(e.expandedItem!==undefined){a.collapsed=true}else{if(a.hasOwnProperty("collapsed")&&a.collapsed===false){e.expandedItem=c}else{a.collapsed=true}}e.owner.mon(a,{show:e.onComponentShow,beforeexpand:e.onComponentExpand,scope:e})}if(e.fill){e.owner.mon(a,{beforecollapse:e.onComponentCollapse,scope:e})}}}if(d&&e.expandedItem===undefined){e.expandedItem=0;b[0].collapsed=false}},getItemsRenderTree:function(a){this.beforeRenderItems(a);return this.callParent(arguments)},renderItems:function(a,b){this.beforeRenderItems(a);this.callParent(arguments)},configureItem:function(a){this.callParent(arguments);a.animCollapse=a.border=false;if(this.fill){a.flex=1}},onChildPanelRender:function(a){a.header.addCls(Ext.baseCSSPrefix+"accordion-hd")},beginLayout:function(a){this.callParent(arguments);this.updatePanelClasses(a)},updatePanelClasses:function(e){var c=e.visibleItems,d=c.length,a=true,b,h,g;for(b=0;b<d;b++){h=c[b];g=h.header;g.addCls(Ext.baseCSSPrefix+"accordion-hd");if(a){g.removeCls(Ext.baseCSSPrefix+"accordion-hd-sibling-expanded")}else{g.addCls(Ext.baseCSSPrefix+"accordion-hd-sibling-expanded")}if(b+1==d&&h.collapsed){g.addCls(Ext.baseCSSPrefix+"accordion-hd-last-collapsed")}else{g.removeCls(Ext.baseCSSPrefix+"accordion-hd-last-collapsed")}a=h.collapsed}},onComponentExpand:function(h){var e=this,a=e.owner,c,g,d,b;if(!e.processing){e.processing=true;b=a.deferLayouts;a.deferLayouts=true;c=e.multi?[]:a.query(">panel:not([collapsed])");g=c.length;for(d=0;d<g;d++){c[d].collapse()}a.deferLayouts=b;e.processing=false}},onComponentCollapse:function(d){var e=this,a=e.owner,g,c,b;if(e.owner.items.getCount()===1){return false}if(!e.processing){e.processing=true;b=a.deferLayouts;a.deferLayouts=true;g=d.next()||d.prev();if(e.multi){c=e.owner.query(">panel:not([collapsed])");if(c.length===1){g.expand()}}else{if(g){g.expand()}}a.deferLayouts=b;e.processing=false}},onComponentShow:function(a){this.onComponentExpand(a)}});Ext.define("Ext.resizer.Splitter",{extend:"Ext.Component",requires:["Ext.XTemplate"],uses:["Ext.resizer.SplitterTracker"],alias:"widget.splitter",childEls:["collapseEl"],renderTpl:['<tpl if="collapsible===true">','<div id="{id}-collapseEl" class="',Ext.baseCSSPrefix,"collapse-el ",Ext.baseCSSPrefix,'layout-split-{collapseDir}">&#160;</div>',"</tpl>"],baseCls:Ext.baseCSSPrefix+"splitter",collapsedClsInternal:Ext.baseCSSPrefix+"splitter-collapsed",canResize:true,collapsible:false,collapseOnDblClick:true,defaultSplitMin:40,defaultSplitMax:1000,collapseTarget:"next",horizontal:false,vertical:false,getTrackerConfig:function(){return{xclass:"Ext.resizer.SplitterTracker",el:this.el,splitter:this}},beforeRender:function(){var d=this,e=d.getCollapseTarget(),g=d.getCollapseDirection(),c=d.vertical,b=c?"width":"height",h=c?"height":"width",a;d.callParent();if(!d.hasOwnProperty(h)){d[h]="100%"}if(!d.hasOwnProperty(b)){d[b]=5}if(e.collapsed){d.addCls(d.collapsedClsInternal)}a=d.baseCls+"-"+d.orientation;d.addCls(a);if(!d.canResize){d.addCls(a+"-noresize")}Ext.applyIf(d.renderData,{collapseDir:g,collapsible:d.collapsible||e.collapsible})},onRender:function(){var a=this;a.callParent(arguments);if(a.performCollapse!==false){if(a.renderData.collapsible){a.mon(a.collapseEl,"click",a.toggleTargetCmp,a)}if(a.collapseOnDblClick){a.mon(a.el,"dblclick",a.toggleTargetCmp,a)}}a.mon(a.getCollapseTarget(),{collapse:a.onTargetCollapse,expand:a.onTargetExpand,scope:a});a.el.unselectable();if(a.canResize){a.tracker=Ext.create(a.getTrackerConfig());a.relayEvents(a.tracker,["beforedragstart","dragstart","dragend"])}},getCollapseDirection:function(){var g=this,c=g.collapseDirection,e,a,b,d;if(!c){e=g.collapseTarget;if(e.isComponent){c=e.collapseDirection}if(!c){d=g.ownerCt.layout.type;if(e.isComponent){b=g.ownerCt.items;a=Number(b.indexOf(e)==b.indexOf(g)-1)<<1|Number(d=="hbox")}else{a=Number(g.collapseTarget=="prev")<<1|Number(d=="hbox")}c=["bottom","right","top","left"][a]}g.collapseDirection=c}g.orientation=(c=="top"||c=="bottom")?"horizontal":"vertical";g[g.orientation]=true;return c},getCollapseTarget:function(){var a=this;return a.collapseTarget.isComponent?a.collapseTarget:a.collapseTarget=="prev"?a.previousSibling():a.nextSibling()},onTargetCollapse:function(a){this.el.addCls([this.collapsedClsInternal,this.collapsedCls])},onTargetExpand:function(a){this.el.removeCls([this.collapsedClsInternal,this.collapsedCls])},toggleTargetCmp:function(d,b){var c=this.getCollapseTarget(),g=c.placeholder,a;if(g&&!g.hidden){a=true}else{a=!c.hidden}if(a){if(c.collapsed){c.expand()}else{if(c.collapseDirection){c.collapse()}else{c.collapse(this.renderData.collapseDir)}}}},setSize:function(){var a=this;a.callParent(arguments);if(Ext.isIE&&a.el){a.el.repaint()}},beforeDestroy:function(){Ext.destroy(this.tracker);this.callParent()}});Ext.define("Ext.resizer.BorderSplitter",{extend:"Ext.resizer.Splitter",uses:["Ext.resizer.BorderSplitterTracker"],alias:"widget.bordersplitter",collapseTarget:null,getTrackerConfig:function(){var a=this.callParent();a.xclass="Ext.resizer.BorderSplitterTracker";return a}});Ext.define("Ext.layout.container.Border",{alias:"layout.border",extend:"Ext.layout.container.Container",requires:["Ext.resizer.BorderSplitter","Ext.Component","Ext.fx.Anim"],alternateClassName:"Ext.layout.BorderLayout",targetCls:Ext.baseCSSPrefix+"border-layout-ct",itemCls:[Ext.baseCSSPrefix+"border-item",Ext.baseCSSPrefix+"box-item"],type:"border",padding:undefined,percentageRe:/(\d+)%/,axisProps:{horz:{borderBegin:"west",borderEnd:"east",horizontal:true,posProp:"x",sizeProp:"width",sizePropCap:"Width"},vert:{borderBegin:"north",borderEnd:"south",horizontal:false,posProp:"y",sizeProp:"height",sizePropCap:"Height"}},centerRegion:null,collapseDirections:{north:"top",south:"bottom",east:"right",west:"left"},manageMargins:true,panelCollapseAnimate:true,panelCollapseMode:"placeholder",regionWeights:{north:20,south:10,center:0,west:-10,east:-20},beginAxis:function(m,b,w){var u=this,c=u.axisProps[w],r=!c.horizontal,l=c.sizeProp,p=0,a=m.childItems,g=a.length,t,q,o,h,s,e,k,n,d,v,j;for(q=0;q<g;++q){o=a[q];s=o.target;o.layoutPos={};if(s.region){o.region=e=s.region;o.isCenter=s.isCenter;o.isHorz=s.isHorz;o.isVert=s.isVert;o.weight=s.weight||u.regionWeights[e]||0;b[s.id]=o;if(s.isCenter){t=o;h=s.flex;m.centerRegion=t;continue}if(r!==o.isVert){continue}o.reverseWeighting=(e==c.borderEnd);n=s[l];d=typeof n;if(!s.collapsed){if(d=="string"&&(k=u.percentageRe.exec(n))){o.percentage=parseInt(k[1],10)}else{if(s.flex){p+=o.flex=s.flex}}}}}if(t){v=t.target;if(j=v.placeholderFor){if(!h&&r===j.collapsedVertical()){h=0;t.collapseAxis=w}}else{if(v.collapsed&&(r===v.collapsedVertical())){h=0;t.collapseAxis=w}}}if(h==null){h=1}p+=h;return Ext.apply({before:r?"top":"left",totalFlex:p},c)},beginLayout:function(d){var l=this,k=l.getLayoutItems(),e=l.padding,m=typeof e,p=false,q,o,b,h,g,a,c,j,n;if(e){if(m=="string"||m=="number"){e=Ext.util.Format.parseBox(e)}}else{e=d.getEl("getTargetEl").getPaddingInfo();p=true}d.outerPad=e;d.padOnContainer=p;for(h=0,b=k.length;h<b;++h){o=k[h];a=l.getSplitterTarget(o);if(a){j=!!o.hidden;if(!a.split){if(a.isCollapsingOrExpanding){c=!!a.collapsed}}else{if(j!==a.hidden){c=!a.hidden}}if(c===true){o.show()}else{if(c===false){o.hide()}}}}l.callParent(arguments);k=d.childItems;b=k.length;g={};d.borderAxisHorz=l.beginAxis(d,g,"horz");d.borderAxisVert=l.beginAxis(d,g,"vert");for(h=0;h<b;++h){q=k[h];a=l.getSplitterTarget(q.target);if(a){n=g[a.id];if(!n){n=d.getEl(a.el,l);n.region=a.region}q.collapseTarget=a=n;q.weight=a.weight;q.reverseWeighting=a.reverseWeighting;a.splitter=q;q.isHorz=a.isHorz;q.isVert=a.isVert}}l.sortWeightedItems(k,"reverseWeighting");l.setupSplitterNeighbors(k)},calculate:function(d){var m=this,a=m.getContainerSize(d),j=d.childItems,c=j.length,b=d.borderAxisHorz,k=d.borderAxisVert,e=d.outerPad,o=d.padOnContainer,h,q,l,p,n,g;b.begin=e.left;k.begin=e.top;n=b.end=b.flexSpace=a.width+(o?e.left:-e.right);g=k.end=k.flexSpace=a.height+(o?e.top:-e.bottom);for(h=0;h<c;++h){q=j[h];l=q.getMarginInfo();if(q.isHorz||q.isCenter){b.addUnflexed(l.width);n-=l.width}if(q.isVert||q.isCenter){k.addUnflexed(l.height);g-=l.height}if(!q.flex&&!q.percentage){if(q.isHorz||(q.isCenter&&q.collapseAxis==="horz")){p=q.getProp("width");b.addUnflexed(p);if(q.collapseTarget){n-=p}}else{if(q.isVert||(q.isCenter&&q.collapseAxis==="vert")){p=q.getProp("height");k.addUnflexed(p);if(q.collapseTarget){g-=p}}}}}for(h=0;h<c;++h){q=j[h];l=q.getMarginInfo();if(q.percentage){if(q.isHorz){p=Math.ceil(n*q.percentage/100);p=q.setWidth(p);b.addUnflexed(p)}else{if(q.isVert){p=Math.ceil(g*q.percentage/100);p=q.setHeight(p);k.addUnflexed(p)}}}}for(h=0;h<c;++h){q=j[h];if(!q.isCenter){m.calculateChildAxis(q,b);m.calculateChildAxis(q,k)}}if(m.finishAxis(d,k)+m.finishAxis(d,b)<2){m.done=false}else{m.finishPositions(j)}},calculateChildAxis:function(l,c){var a=l.collapseTarget,h="set"+c.sizePropCap,e=c.sizeProp,d=l.getMarginInfo()[e],j,b,g,i,k;if(a){j=a.region}else{j=l.region;g=l.flex}b=j==c.borderBegin;if(!b&&j!=c.borderEnd){l[h](c.end-c.begin-d);i=c.begin}else{if(g){k=Math.ceil(c.flexSpace*(g/c.totalFlex));k=l[h](k)}else{if(l.percentage){k=l.peek(e)}else{k=l.getProp(e)}}k+=d;if(b){i=c.begin;c.begin+=k}else{c.end=i=c.end-k}}l.layoutPos[c.posProp]=i},finishAxis:function(d,c){var b=c.end-c.begin,a=d.centerRegion;if(a){a["set"+c.sizePropCap](b-a.getMarginInfo()[c.sizeProp]);a.layoutPos[c.posProp]=c.begin}return Ext.isNumber(b)?1:0},finishPositions:function(d){var c=d.length,b,a;for(b=0;b<c;++b){a=d[b];a.setProp("x",a.layoutPos.x+a.marginInfo.left);a.setProp("y",a.layoutPos.y+a.marginInfo.top)}},getPlaceholder:function(a){return a.getPlaceholder&&a.getPlaceholder()},getSplitterTarget:function(b){var a=b.collapseTarget;if(a&&a.collapsed){return a.placeholder||a}return a},isItemBoxParent:function(a){return true},isItemShrinkWrap:function(a){return true},insertSplitter:function(c,b,e){var g=c.region,d={xtype:"bordersplitter",collapseTarget:c,id:c.id+"-splitter",hidden:e,canResize:c.splitterResize!==false},a=b+((g=="south"||g=="east")?0:1);if(c.isHorz){d.height=null}else{d.width=null}if(c.collapseMode=="mini"){d.collapsedCls=c.collapsedCls}c.splitter=this.owner.add(a,d)},onAdd:function(d,a){var c=this,h=d.placeholderFor,g=d.region,b,e;c.callParent(arguments);if(g){Ext.apply(d,c.regionFlags[g]);if(g=="center"){c.centerRegion=d}else{d.collapseDirection=this.collapseDirections[g];b=d.split;e=!!d.hidden;if((d.isHorz||d.isVert)&&(b||d.collapseMode=="mini")){c.insertSplitter(d,a,e||!b)}}if(!d.hasOwnProperty("collapseMode")){d.collapseMode=c.panelCollapseMode}if(!d.hasOwnProperty("animCollapse")){if(d.collapseMode!="placeholder"){d.animCollapse=false}else{d.animCollapse=c.panelCollapseAnimate}}}else{if(h){Ext.apply(d,c.regionFlags[h.region]);d.region=h.region;d.weight=h.weight}}},onDestroy:function(){this.centerRegion=null;this.callParent()},onRemove:function(b){var a=this,d=b.region,c=b.splitter;if(d){if(b.isCenter){a.centerRegion=null}delete b.isCenter;delete b.isHorz;delete b.isVert;if(c){a.owner.doRemove(c,true);delete b.splitter}}a.callParent(arguments)},regionFlags:{center:{isCenter:true,isHorz:false,isVert:false},north:{isCenter:false,isHorz:false,isVert:true},south:{isCenter:false,isHorz:false,isVert:true},west:{isCenter:false,isHorz:true,isVert:false},east:{isCenter:false,isHorz:true,isVert:false}},setupSplitterNeighbors:function(m){var p={},e=m.length,o=this.touchedRegions,h,g,a,l,d,k,n,b,c;for(h=0;h<e;++h){k=m[h].target;n=k.region;if(k.isCenter){a=k}else{if(n){c=o[n];for(g=0,l=c.length;g<l;++g){d=p[c[g]];if(d){d.neighbors.push(k)}}if(k.placeholderFor){b=k.placeholderFor.splitter}else{b=k.splitter}if(b){b.neighbors=[]}p[n]=b}}}if(a){c=o.center;for(g=0,l=c.length;g<l;++g){d=p[c[g]];if(d){d.neighbors.push(a)}}}},touchedRegions:{center:["north","south","east","west"],north:["north","east","west"],south:["south","east","west"],east:["east","north","south"],west:["west","north","south"]},sizePolicies:{vert:{setsWidth:1,setsHeight:0},horz:{setsWidth:0,setsHeight:1},flexAll:{setsWidth:1,setsHeight:1}},getItemSizePolicy:function(e){var d=this,a=this.sizePolicies,c,b,g,h;if(e.isCenter){h=e.placeholderFor;if(h){if(h.collapsedVertical()){return a.vert}return a.horz}if(e.collapsed){if(e.collapsedVertical()){return a.vert}return a.horz}return a.flexAll}c=e.collapseTarget;if(c){return c.isVert?a.vert:a.horz}if(e.region){if(e.isVert){b=e.height;g=a.vert}else{b=e.width;g=a.horz}if(e.flex||(typeof b=="string"&&d.percentageRe.test(b))){return a.flexAll}return g}return d.autoSizePolicy}},function(){var a={addUnflexed:function(c){this.flexSpace=Math.max(this.flexSpace-c,0)}},b=this.prototype.axisProps;Ext.apply(b.horz,a);Ext.apply(b.vert,a)});Ext.define("Ext.layout.container.Card",{extend:"Ext.layout.container.Fit",alternateClassName:"Ext.layout.CardLayout",alias:"layout.card",type:"card",hideInactive:true,deferredRender:false,getRenderTree:function(){var a=this,b=a.getActiveItem();if(b){if(b.hasListeners.beforeactivate&&b.fireEvent("beforeactivate",b)===false){b=a.activeItem=a.owner.activeItem=null}else{if(b.hasListeners.activate){b.on({boxready:function(){b.fireEvent("activate",b)},single:true})}}if(a.deferredRender){if(b){return a.getItemsRenderTree([b])}}else{return a.callParent(arguments)}}},renderChildren:function(){var a=this,b=a.getActiveItem();if(!a.deferredRender){a.callParent()}else{if(b){a.renderItems([b],a.getRenderTarget())}}},isValidParent:function(c,d,a){var b=c.el?c.el.dom:Ext.getDom(c);return(b&&b.parentNode===(d.dom||d))||false},getActiveItem:function(){var b=this,a=b.parseActiveItem(b.activeItem||(b.owner&&b.owner.activeItem));if(a&&b.owner.items.indexOf(a)!=-1){b.activeItem=a}else{b.activeItem=null}return b.activeItem},parseActiveItem:function(a){if(a&&a.isComponent){return a}else{if(typeof a=="number"||a===undefined){return this.getLayoutItems()[a||0]}else{return this.owner.getComponent(a)}}},configureItem:function(a){if(a===this.getActiveItem()){a.hidden=false}else{a.hidden=true}this.callParent(arguments)},onRemove:function(a){var b=this;if(a===b.activeItem){b.activeItem=null}},getAnimation:function(b,a){var c=(b||{}).cardSwitchAnimation;if(c===false){return false}return c||a.cardSwitchAnimation},getNext:function(){var c=arguments[0],a=this.getLayoutItems(),b=Ext.Array.indexOf(a,this.activeItem);return a[b+1]||(c?a[0]:false)},next:function(){var b=arguments[0],a=arguments[1];return this.setActiveItem(this.getNext(a),b)},getPrev:function(){var c=arguments[0],a=this.getLayoutItems(),b=Ext.Array.indexOf(a,this.activeItem);return a[b-1]||(c?a[a.length-1]:false)},prev:function(){var b=arguments[0],a=arguments[1];return this.setActiveItem(this.getPrev(a),b)},setActiveItem:function(b){var e=this,a=e.owner,d=e.activeItem,g=a.rendered,c;b=e.parseActiveItem(b);c=a.items.indexOf(b);if(c==-1){c=a.items.items.length;Ext.suspendLayouts();b=a.add(b);Ext.resumeLayouts()}if(b&&d!=b){if(b.fireEvent("beforeactivate",b,d)===false){return false}if(d&&d.fireEvent("beforedeactivate",d,b)===false){return false}if(g){Ext.suspendLayouts();if(!b.rendered){e.renderItem(b,e.getRenderTarget(),a.items.length)}if(d){if(e.hideInactive){d.hide();d.hiddenByLayout=true}d.fireEvent("deactivate",d,b)}if(b.hidden){b.show()}if(!b.hidden){e.activeItem=b}Ext.resumeLayouts(true)}else{e.activeItem=b}b.fireEvent("activate",b,d);return e.activeItem}return false}});Ext.define("Ext.layout.container.Column",{extend:"Ext.layout.container.Container",alias:["layout.column"],alternateClassName:"Ext.layout.ColumnLayout",type:"column",itemCls:Ext.baseCSSPrefix+"column",targetCls:Ext.baseCSSPrefix+"column-layout-ct",columnWidthSizePolicy:{setsWidth:1,setsHeight:0},childEls:["innerCt"],manageOverflow:2,renderTpl:['<div id="{ownerId}-innerCt" class="',Ext.baseCSSPrefix,'column-inner">',"{%this.renderBody(out,values)%}",'<div class="',Ext.baseCSSPrefix,'clear"></div>',"</div>","{%this.renderPadder(out,values)%}"],getItemSizePolicy:function(a){if(a.columnWidth){return this.columnWidthSizePolicy}return this.autoSizePolicy},beginLayout:function(){this.callParent(arguments);this.innerCt.dom.style.width=""},calculate:function(c){var a=this,d=a.getContainerSize(c),b=c.state;if(b.calculatedColumns||(b.calculatedColumns=a.calculateColumns(c))){if(a.calculateHeights(c)){a.calculateOverflow(c,d);return}}a.done=false},calculateColumns:function(d){var m=this,a=m.getContainerSize(d),o=d.getEl("innerCt",m),l=d.childItems,j=l.length,b=0,g,n,e,c,h,k;if(!d.heightModel.shrinkWrap&&!d.targetContext.hasProp("height")){return false}if(!a.gotWidth){d.targetContext.block(m,"width");g=true}else{n=a.width;o.setWidth(n)}for(e=0;e<j;++e){c=l[e];h=c.getMarginInfo().width;if(!c.widthModel.calculated){k=c.getProp("width");if(typeof k!="number"){c.block(m,"width");g=true}b+=k+h}}if(!g){n=(n<b)?0:n-b;for(e=0;e<j;++e){c=l[e];if(c.widthModel.calculated){h=c.marginInfo.width;k=c.target.columnWidth;k=Math.floor(k*n)-h;k=c.setWidth(k);b+=k+h}}d.setContentWidth(b)}return !g},calculateHeights:function(h){var g=this,b=h.childItems,a=b.length,c,d,e;c=false;for(d=0;d<a;++d){e=b[d];if(!e.hasDomProp("height")){e.domBlock(g,"height");c=true}}if(!c){h.setContentHeight(g.innerCt.getHeight()+h.targetContext.getPaddingInfo().height)}return !c},finishedLayout:function(a){var b=a.bodyContext;if(b&&(Ext.isIE6||Ext.isIE7||Ext.isIEQuirks)){b.el.repaint()}this.callParent(arguments)},getRenderTarget:function(){return this.innerCt}});Ext.define("Ext.layout.container.Form",{alias:"layout.form",extend:"Ext.layout.container.Auto",alternateClassName:"Ext.layout.FormLayout",tableCls:Ext.baseCSSPrefix+"form-layout-table",type:"form",manageOverflow:2,childEls:["formTable"],padRow:'<tr><td class="'+Ext.baseCSSPrefix+'form-item-pad" colspan="3"></td></tr>',renderTpl:['<table id="{ownerId}-formTable" class="{tableCls}" style="width:100%" cellpadding="0">',"{%this.renderBody(out,values)%}","</table>","{%this.renderPadder(out,values)%}"],getRenderData:function(){var a=this.callParent();a.tableCls=this.tableCls;return a},calculate:function(e){var d=this,h=d.getContainerSize(e,true),a,g,b=0,c;if(h.gotWidth){this.callParent(arguments);a=d.formTable.dom.offsetWidth;g=e.childItems;for(c=g.length;b<c;++b){g[b].setWidth(a,false)}}else{d.done=false}},getRenderTarget:function(){return this.formTable},getRenderTree:function(){var d=this,b=d.callParent(arguments),c,a;for(c=0,a=b.length;c<a;c++){b[c]=d.transformItemRenderTree(b[c])}return b},transformItemRenderTree:function(a){if(a.tag&&a.tag=="table"){a.tag="tbody";delete a.cellspacing;delete a.cellpadding;if(Ext.isIE6){a.cn=this.padRow}return a}return{tag:"tbody",cn:{tag:"tr",cn:{tag:"td",colspan:3,style:"width:100%",cn:a}}}},isValidParent:function(b,c,a){return true},isItemShrinkWrap:function(a){return((a.shrinkWrap===true)?3:a.shrinkWrap||0)&2},getItemSizePolicy:function(a){return{setsWidth:1,setsHeight:0}}});Ext.define("Ext.menu.Item",{extend:"Ext.Component",alias:"widget.menuitem",alternateClassName:"Ext.menu.TextItem",activeCls:Ext.baseCSSPrefix+"menu-item-active",ariaRole:"menuitem",canActivate:true,clickHideDelay:1,destroyMenu:true,disabledCls:Ext.baseCSSPrefix+"menu-item-disabled",hideOnClick:true,isMenuItem:true,menuAlign:"tl-tr?",menuExpandDelay:200,menuHideDelay:200,tooltipType:"qtip",arrowCls:Ext.baseCSSPrefix+"menu-item-arrow",childEls:["itemEl","iconEl","textEl","arrowEl"],renderTpl:['<tpl if="plain">',"{text}","<tpl else>",'<a id="{id}-itemEl" class="'+Ext.baseCSSPrefix+'menu-item-link" href="{href}" <tpl if="hrefTarget">target="{hrefTarget}"</tpl> hidefocus="true" unselectable="on">','<img id="{id}-iconEl" src="{icon}" class="'+Ext.baseCSSPrefix+'menu-item-icon {iconCls}" />','<span id="{id}-textEl" class="'+Ext.baseCSSPrefix+'menu-item-text" <tpl if="arrowCls">style="margin-right: 17px;"</tpl> >{text}</span>','<img id="{id}-arrowEl" src="{blank}" class="{arrowCls}" />',"</a>","</tpl>"],maskOnDisable:false,activate:function(){var a=this;if(!a.activated&&a.canActivate&&a.rendered&&!a.isDisabled()&&a.isVisible()){a.el.addCls(a.activeCls);a.focus();a.activated=true;a.fireEvent("activate",a)}},getFocusEl:function(){return this.itemEl},deactivate:function(){var a=this;if(a.activated){a.el.removeCls(a.activeCls);a.blur();a.hideMenu();a.activated=false;a.fireEvent("deactivate",a)}},deferExpandMenu:function(){var a=this;if(a.activated&&(!a.menu.rendered||!a.menu.isVisible())){a.parentMenu.activeChild=a.menu;a.menu.parentItem=a;a.menu.parentMenu=a.menu.ownerCt=a.parentMenu;a.menu.showBy(a,a.menuAlign)}},deferHideMenu:function(){if(this.menu.isVisible()){this.menu.hide()}},cancelDeferHide:function(){clearTimeout(this.hideMenuTimer)},deferHideParentMenus:function(){var a;Ext.menu.Manager.hideAll();if(!Ext.Element.getActiveElement()){a=this.up(":not([hidden])");if(a){a.focus()}}},expandMenu:function(a){var b=this;if(b.menu){b.cancelDeferHide();if(a===0){b.deferExpandMenu()}else{b.expandMenuTimer=Ext.defer(b.deferExpandMenu,Ext.isNumber(a)?a:b.menuExpandDelay,b)}}},getRefItems:function(a){var c=this.menu,b;if(c){b=c.getRefItems(a);b.unshift(c)}return b||[]},hideMenu:function(a){var b=this;if(b.menu){clearTimeout(b.expandMenuTimer);b.hideMenuTimer=Ext.defer(b.deferHideMenu,Ext.isNumber(a)?a:b.menuHideDelay,b)}},initComponent:function(){var b=this,c=Ext.baseCSSPrefix,a=[c+"menu-item"],d;b.addEvents("activate","click","deactivate");if(b.plain){a.push(c+"menu-item-plain")}if(b.cls){a.push(b.cls)}b.cls=a.join(" ");if(b.menu){d=b.menu;delete b.menu;b.setMenu(d)}b.callParent(arguments)},onClick:function(b){var a=this;if(!a.href){b.stopEvent()}if(a.disabled){return}if(a.hideOnClick){a.deferHideParentMenusTimer=Ext.defer(a.deferHideParentMenus,a.clickHideDelay,a)}Ext.callback(a.handler,a.scope||a,[a,b]);a.fireEvent("click",a,b);if(!a.hideOnClick){a.focus()}},onRemoved:function(){var a=this;if(a.activated&&a.parentMenu.activeItem===a){a.parentMenu.deactivateActiveItem()}a.callParent(arguments);delete a.parentMenu;delete a.ownerButton},beforeDestroy:function(){var a=this;if(a.rendered){a.clearTip()}a.callParent()},onDestroy:function(){var a=this;clearTimeout(a.expandMenuTimer);a.cancelDeferHide();clearTimeout(a.deferHideParentMenusTimer);a.setMenu(null);a.callParent(arguments)},beforeRender:function(){var b=this,d=Ext.BLANK_IMAGE_URL,a,c;b.callParent();if(b.iconAlign==="right"){a=b.checkChangeDisabled?b.disabledCls:"";c=Ext.baseCSSPrefix+"menu-item-icon-right "+b.iconCls}else{a=b.iconCls+(b.checkChangeDisabled?" "+b.disabledCls:"");c=b.menu?b.arrowCls:""}Ext.applyIf(b.renderData,{href:b.href||"#",hrefTarget:b.hrefTarget,icon:b.icon||d,iconCls:a,plain:b.plain,text:b.text,arrowCls:c,blank:d})},onRender:function(){var a=this;a.callParent(arguments);if(a.tooltip){a.setTooltip(a.tooltip,true)}},setMenu:function(e,d){var c=this,b=c.menu,a=c.arrowEl;if(b){delete b.parentItem;delete b.parentMenu;delete b.ownerCt;delete b.ownerItem;if(d===true||(d!==false&&c.destroyMenu)){Ext.destroy(b)}}if(e){c.menu=Ext.menu.Manager.get(e);c.menu.ownerItem=c}else{c.menu=null}if(c.rendered&&!c.destroying&&a){a[c.menu?"addCls":"removeCls"](c.arrowCls)}},setHandler:function(b,a){this.handler=b||null;this.scope=a},setIcon:function(b){var a=this.iconEl;if(a){a.src=b||Ext.BLANK_IMAGE_URL}this.icon=b},setIconCls:function(b){var c=this,a=c.iconEl;if(a){if(c.iconCls){a.removeCls(c.iconCls)}if(b){a.addCls(b)}}c.iconCls=b},setText:function(c){var b=this,a=b.textEl||b.el;b.text=c;if(b.rendered){a.update(c||"");b.ownerCt.updateLayout()}},getTipAttr:function(){return this.tooltipType=="qtip"?"data-qtip":"title"},clearTip:function(){if(Ext.isObject(this.tooltip)){Ext.tip.QuickTipManager.unregister(this.itemEl)}},setTooltip:function(c,a){var b=this;if(b.rendered){if(!a){b.clearTip()}if(Ext.isObject(c)){Ext.tip.QuickTipManager.register(Ext.apply({target:b.itemEl.id},c));b.tooltip=c}else{b.itemEl.dom.setAttribute(b.getTipAttr(),c)}}else{b.tooltip=c}return b}});Ext.define("Ext.menu.CheckItem",{extend:"Ext.menu.Item",alias:"widget.menucheckitem",checkedCls:Ext.baseCSSPrefix+"menu-item-checked",uncheckedCls:Ext.baseCSSPrefix+"menu-item-unchecked",groupCls:Ext.baseCSSPrefix+"menu-group-icon",hideOnClick:false,checkChangeDisabled:false,afterRender:function(){var a=this;a.callParent();a.checked=!a.checked;a.setChecked(!a.checked,true);if(a.checkChangeDisabled){a.disableCheckChange()}},initComponent:function(){var a=this;a.addEvents("beforecheckchange","checkchange");a.callParent(arguments);Ext.menu.Manager.registerCheckable(a);if(a.group){if(!a.iconCls){a.iconCls=a.groupCls}if(a.initialConfig.hideOnClick!==false){a.hideOnClick=true}}},disableCheckChange:function(){var b=this,a=b.iconEl;if(a){a.addCls(b.disabledCls)}if(!(Ext.isIE9&&Ext.isStrict)&&b.rendered){b.el.repaint()}b.checkChangeDisabled=true},enableCheckChange:function(){var b=this,a=b.iconEl;if(a){a.removeCls(b.disabledCls)}b.checkChangeDisabled=false},onClick:function(b){var a=this;if(!a.disabled&&!a.checkChangeDisabled&&!(a.checked&&a.group)){a.setChecked(!a.checked)}this.callParent([b])},onDestroy:function(){Ext.menu.Manager.unregisterCheckable(this);this.callParent(arguments)},setChecked:function(c,a){var b=this;if(b.checked!==c&&(a||b.fireEvent("beforecheckchange",b,c)!==false)){if(b.el){b.el[c?"addCls":"removeCls"](b.checkedCls)[!c?"addCls":"removeCls"](b.uncheckedCls)}b.checked=c;Ext.menu.Manager.onCheckChange(b,c);if(!a){Ext.callback(b.checkHandler,b.scope,[b,c]);b.fireEvent("checkchange",b,c)}}}});Ext.define("Ext.menu.KeyNav",{extend:"Ext.util.KeyNav",requires:["Ext.FocusManager"],constructor:function(b){var a=this;a.menu=b;a.callParent([b.el,{down:a.down,enter:a.enter,esc:a.escape,left:a.left,right:a.right,space:a.enter,tab:a.tab,up:a.up}])},down:function(b){var a=this,c=a.menu.focusedItem;if(c&&b.getKey()==Ext.EventObject.DOWN&&a.isWhitelisted(c)){return true}a.focusNextItem(1)},enter:function(b){var c=this.menu,a=c.focusedItem;if(c.activeItem){c.onClick(b)}else{if(a&&a.isFormField){return true}}},escape:function(a){Ext.menu.Manager.hideAll()},focusNextItem:function(g){var h=this.menu,b=h.items,d=h.focusedItem,c=d?b.indexOf(d):-1,a=c+g,e;while(a!=c){if(a<0){a=b.length-1}else{if(a>=b.length){a=0}}e=b.getAt(a);if(h.canActivateItem(e)){h.setActiveItem(e);break}a+=g}},isWhitelisted:function(a){return Ext.FocusManager.isWhitelisted(a)},left:function(b){var c=this.menu,d=c.focusedItem,a=c.activeItem;if(d&&this.isWhitelisted(d)){return true}c.hide();if(c.parentMenu){c.parentMenu.focus()}},right:function(c){var d=this.menu,g=d.focusedItem,a=d.activeItem,b;if(g&&this.isWhitelisted(g)){return true}if(a){b=d.activeItem.menu;if(b){a.expandMenu(0);Ext.defer(function(){b.setActiveItem(b.items.getAt(0))},25)}}},tab:function(b){var a=this;if(b.shiftKey){a.up(b)}else{a.down(b)}},up:function(b){var a=this,c=a.menu.focusedItem;if(c&&b.getKey()==Ext.EventObject.UP&&a.isWhitelisted(c)){return true}a.focusNextItem(-1)}});Ext.define("Ext.menu.Separator",{extend:"Ext.menu.Item",alias:"widget.menuseparator",canActivate:false,focusable:false,hideOnClick:false,plain:true,separatorCls:Ext.baseCSSPrefix+"menu-item-separator",text:"&#160;",beforeRender:function(a,c){var b=this;b.callParent();b.addCls(b.separatorCls)}});Ext.define("Ext.menu.Menu",{extend:"Ext.panel.Panel",alias:"widget.menu",requires:["Ext.layout.container.Fit","Ext.layout.container.VBox","Ext.menu.CheckItem","Ext.menu.Item","Ext.menu.KeyNav","Ext.menu.Manager","Ext.menu.Separator"],enableKeyNav:true,allowOtherMenus:false,ariaRole:"menu",defaultAlign:"tl-bl?",floating:true,constrain:true,hidden:true,hideMode:"visibility",ignoreParentClicks:false,isMenu:true,showSeparator:true,minWidth:undefined,defaultMinWidth:120,initComponent:function(){var b=this,d=Ext.baseCSSPrefix,a=[d+"menu"],c=b.bodyCls?[b.bodyCls]:[],e=b.floating!==false;b.addEvents("click","mouseenter","mouseleave","mouseover");Ext.menu.Manager.register(b);if(b.plain){a.push(d+"menu-plain")}b.cls=a.join(" ");c.unshift(d+"menu-body");b.bodyCls=c.join(" ");if(!b.layout){b.layout={type:"vbox",align:"stretchmax",overflowHandler:"Scroller"}}if(e&&b.minWidth===undefined){b.minWidth=b.defaultMinWidth}if(!e&&b.initialConfig.hidden!==true){b.hidden=false}b.callParent(arguments);b.on("beforeshow",function(){var g=!!b.items.length;if(g&&b.rendered){b.el.setStyle("visibility",null)}return g})},beforeRender:function(){this.callParent(arguments);if(!this.getSizeModel().width.shrinkWrap){this.layout.align="stretch"}},onBoxReady:function(){var a=this,b;a.callParent(arguments);if(a.showSeparator){b={cls:Ext.baseCSSPrefix+"menu-icon-separator",html:"&#160;"};if((!Ext.isStrict&&Ext.isIE)||Ext.isIE6){b.style="height:"+a.el.getHeight()+"px"}a.iconSepEl=a.layout.getElementTarget().insertFirst(b)}a.mon(a.el,{click:a.onClick,mouseover:a.onMouseOver,scope:a});a.mouseMonitor=a.el.monitorMouseLeave(100,a.onMouseLeave,a);if(a.enableKeyNav){a.keyNav=new Ext.menu.KeyNav(a)}},getBubbleTarget:function(){return this.parentMenu||this.ownerButton||this.callParent(arguments)},canActivateItem:function(a){return a&&!a.isDisabled()&&a.isVisible()&&(a.canActivate||a.getXTypes().indexOf("menuitem")<0)},deactivateActiveItem:function(b){var c=this,d=c.activeItem,a=c.focusedItem;if(d){d.deactivate();if(!d.activated){delete c.activeItem}}if(a&&b){a.blur();delete c.focusedItem}},getFocusEl:function(){return this.focusedItem||this.el},hide:function(){this.deactivateActiveItem(true);this.callParent(arguments)},getItemFromEvent:function(a){return this.getChildByElement(a.getTarget())},lookupComponent:function(b){var a=this;if(typeof b=="string"){b=a.lookupItemFromString(b)}else{if(Ext.isObject(b)){b=a.lookupItemFromObject(b)}}b.minWidth=b.minWidth||a.minWidth;return b},lookupItemFromObject:function(c){var b=this,d=Ext.baseCSSPrefix,a;if(!c.isComponent){if(!c.xtype){c=Ext.create("Ext.menu."+(Ext.isBoolean(c.checked)?"Check":"")+"Item",c)}else{c=Ext.ComponentManager.create(c,c.xtype)}}if(c.isMenuItem){c.parentMenu=b}if(!c.isMenuItem&&!c.dock){a=[d+"menu-item",d+"menu-item-cmp"];if(!b.plain&&(c.indent===true||c.iconCls==="no-icon")){a.push(d+"menu-item-indent")}if(c.rendered){c.el.addCls(a)}else{c.cls=(c.cls?c.cls:"")+" "+a.join(" ")}}return c},lookupItemFromString:function(a){return(a=="separator"||a=="-")?new Ext.menu.Separator():new Ext.menu.Item({canActivate:false,hideOnClick:false,plain:true,text:a})},onClick:function(c){var b=this,a;if(b.disabled){c.stopEvent();return}a=(c.type==="click")?b.getItemFromEvent(c):b.activeItem;if(a&&a.isMenuItem){if(!a.menu||!b.ignoreParentClicks){a.onClick(c)}else{c.stopEvent()}}if(!a||a.disabled){a=undefined}b.fireEvent("click",b,a,c)},onDestroy:function(){var a=this;Ext.menu.Manager.unregister(a);delete a.parentMenu;delete a.ownerButton;if(a.rendered){a.el.un(a.mouseMonitor);Ext.destroy(a.keyNav);delete a.keyNav}a.callParent(arguments)},onMouseLeave:function(b){var a=this;a.deactivateActiveItem();if(a.disabled){return}a.fireEvent("mouseleave",a,b)},onMouseOver:function(h){var g=this,i=h.getRelatedTarget(),b=!g.el.contains(i),d=g.getItemFromEvent(h),c=g.parentMenu,a=g.parentItem;if(b&&c){c.setActiveItem(a);a.cancelDeferHide();c.mouseMonitor.mouseenter()}if(g.disabled){return}if(d&&!d.activated){g.setActiveItem(d);if(d.activated&&d.expandMenu){d.expandMenu()}}if(b){g.fireEvent("mouseenter",g,h)}g.fireEvent("mouseover",g,d,h)},setActiveItem:function(b){var a=this;if(b&&(b!=a.activeItem)){a.deactivateActiveItem();if(a.canActivateItem(b)){if(b.activate){b.activate();if(b.activated){a.activeItem=b;a.focusedItem=b;a.focus()}}else{b.focus();a.focusedItem=b}}b.el.scrollIntoView(a.layout.getRenderTarget())}},showBy:function(b,d,c){var a=this;if(a.floating&&b){a.show();a.setPagePosition(a.el.getAlignToXY(b.el||b,d||a.defaultAlign,c));a.setVerticalPosition()}return a},show:function(){var d=this,c,b,a,e=d.maxHeight;if(!d.rendered){d.doAutoRender()}if(d.floating){c=Ext.fly(d.el.getScopeParent());b=c.getViewSize().height;d.maxHeight=Math.min(e||b,b)}a=d.callParent(arguments);d.maxHeight=e;return a},afterComponentLayout:function(c,a,b,e){var d=this;d.callParent(arguments);if(d.showSeparator){d.iconSepEl.setHeight(d.componentLayout.lastComponentSize.contentHeight)}},setVerticalPosition:function(){var d=this,g,e=d.el.getY(),h=e,j=d.getHeight(),b=Ext.Element.getViewportHeight().height,c=Ext.fly(d.el.getScopeParent()),a=c.getViewSize().height,i=e-c.getScroll().top;c=null;if(d.floating){g=d.maxHeight?d.maxHeight:a-i;if(j>a){h=e-i}else{if(g<j){h=e-(j-g)}else{if((e+j)>b){h=b-j}}}}d.el.setY(h)}});Ext.define("Ext.menu.ColorPicker",{extend:"Ext.menu.Menu",alias:"widget.colormenu",requires:["Ext.picker.Color"],hideOnClick:true,pickerId:null,initComponent:function(){var b=this,a=Ext.apply({},b.initialConfig);delete a.listeners;Ext.apply(b,{plain:true,showSeparator:false,items:Ext.applyIf({cls:Ext.baseCSSPrefix+"menu-color-item",id:b.pickerId,xtype:"colorpicker"},a)});b.callParent(arguments);b.picker=b.down("colorpicker");b.relayEvents(b.picker,["select"]);if(b.hideOnClick){b.on("select",b.hidePickerOnSelect,b)}},hidePickerOnSelect:function(){Ext.menu.Manager.hideAll()}});Ext.define("Ext.menu.DatePicker",{extend:"Ext.menu.Menu",alias:"widget.datemenu",requires:["Ext.picker.Date"],hideOnClick:true,pickerId:null,initComponent:function(){var b=this,a=Ext.apply({},b.initialConfig);delete a.listeners;Ext.apply(b,{showSeparator:false,plain:true,border:false,bodyPadding:0,items:Ext.applyIf({cls:Ext.baseCSSPrefix+"menu-date-item",id:b.pickerId,xtype:"datepicker"},a)});b.callParent(arguments);b.picker=b.down("datepicker");b.relayEvents(b.picker,["select"]);if(b.hideOnClick){b.on("select",b.hidePickerOnSelect,b)}},hidePickerOnSelect:function(){Ext.menu.Manager.hideAll()}});Ext.define("Ext.panel.Tool",{extend:"Ext.Component",requires:["Ext.tip.QuickTipManager"],alias:"widget.tool",baseCls:Ext.baseCSSPrefix+"tool",disabledCls:Ext.baseCSSPrefix+"tool-disabled",toolPressedCls:Ext.baseCSSPrefix+"tool-pressed",toolOverCls:Ext.baseCSSPrefix+"tool-over",ariaRole:"button",childEls:["toolEl"],renderTpl:['<img id="{id}-toolEl" src="{blank}" class="{baseCls}-{type}" role="presentation"/>'],tooltipType:"qtip",stopEvent:true,height:15,width:15,initComponent:function(){var a=this;a.addEvents("click");a.type=a.type||a.id;Ext.applyIf(a.renderData,{baseCls:a.baseCls,blank:Ext.BLANK_IMAGE_URL,type:a.type});a.tooltip=a.tooltip||a.qtip;a.callParent();a.on({element:"toolEl",click:a.onClick,mousedown:a.onMouseDown,mouseover:a.onMouseOver,mouseout:a.onMouseOut,scope:a})},afterRender:function(){var b=this,a;b.callParent(arguments);if(b.tooltip){if(Ext.isObject(b.tooltip)){Ext.tip.QuickTipManager.register(Ext.apply({target:b.id},b.tooltip))}else{a=b.tooltipType=="qtip"?"data-qtip":"title";b.toolEl.dom.setAttribute(a,b.tooltip)}}},getFocusEl:function(){return this.el},setType:function(a){var b=this;b.type=a;if(b.rendered){b.toolEl.dom.className=b.baseCls+"-"+a}return b},bindTo:function(a){this.owner=a},onClick:function(d,c){var b=this,a;if(b.disabled){return false}a=b.owner||b.ownerCt;b.el.removeCls(b.toolPressedCls);b.el.removeCls(b.toolOverCls);if(b.stopEvent!==false){d.stopEvent()}Ext.callback(b.handler,b.scope||b,[d,c,a,b]);b.fireEvent("click",b,d);return true},onDestroy:function(){if(Ext.isObject(this.tooltip)){Ext.tip.QuickTipManager.unregister(this.id)}this.callParent()},onMouseDown:function(){if(this.disabled){return false}this.el.addCls(this.toolPressedCls)},onMouseOver:function(){if(this.disabled){return false}this.el.addCls(this.toolOverCls)},onMouseOut:function(){this.el.removeCls(this.toolOverCls)}});Ext.define("Ext.resizer.SplitterTracker",{extend:"Ext.dd.DragTracker",requires:["Ext.util.Region"],enabled:true,overlayCls:Ext.baseCSSPrefix+"resizable-overlay",createDragOverlay:function(){var a;a=this.overlay=Ext.getBody().createChild({cls:this.overlayCls,html:"&#160;"});a.unselectable();a.setSize(Ext.Element.getViewWidth(true),Ext.Element.getViewHeight(true));a.show()},getPrevCmp:function(){var a=this.getSplitter();return a.previousSibling()},getNextCmp:function(){var a=this.getSplitter();return a.nextSibling()},onBeforeStart:function(i){var d=this,g=d.getPrevCmp(),a=d.getNextCmp(),c=d.getSplitter().collapseEl,h=i.getTarget(),b;if(c&&h===d.getSplitter().collapseEl.dom){return false}if(a.collapsed||g.collapsed){return false}d.prevBox=g.getEl().getBox();d.nextBox=a.getEl().getBox();d.constrainTo=b=d.calculateConstrainRegion();if(!b){return false}d.createDragOverlay();return b},onStart:function(b){var a=this.getSplitter();a.addCls(a.baseCls+"-active")},calculateConstrainRegion:function(){var g=this,a=g.getSplitter(),h=a.getWidth(),i=a.defaultSplitMin,b=a.orientation,d=g.prevBox,j=g.getPrevCmp(),c=g.nextBox,e=g.getNextCmp(),l,k;if(b==="vertical"){l=new Ext.util.Region(d.y,(j.maxWidth?d.x+j.maxWidth:c.right-(e.minWidth||i))+h,d.bottom,d.x+(j.minWidth||i));k=new Ext.util.Region(c.y,c.right-(e.minWidth||i),c.bottom,(e.maxWidth?c.right-e.maxWidth:d.x+(d.minWidth||i))-h)}else{l=new Ext.util.Region(d.y+(j.minHeight||i),d.right,(j.maxHeight?d.y+j.maxHeight:c.bottom-(e.minHeight||i))+h,d.x);k=new Ext.util.Region((e.maxHeight?c.bottom-e.maxHeight:d.y+(j.minHeight||i))-h,c.right,c.bottom-(e.minHeight||i),c.x)}return l.intersect(k)},performResize:function(m,g){var o=this,a=o.getSplitter(),h=a.orientation,p=o.getPrevCmp(),n=o.getNextCmp(),b=a.ownerCt,k=b.query(">[flex]"),l=k.length,j=0,d,q,c=0;for(;j<l;j++){q=k[j].getWidth();c+=q;k[j].flex=q}g=g||o.getOffset("dragTarget");if(h==="vertical"){g=g[0];d="width"}else{d="height";g=g[1]}if(p){q=o.prevBox[d]+g;if(p.flex){p.flex=q}else{p[d]=q}}if(n){q=o.nextBox[d]-g;if(n.flex){n.flex=q}else{n[d]=q}}b.updateLayout()},endDrag:function(){var a=this;if(a.overlay){a.overlay.remove();delete a.overlay}a.callParent(arguments)},onEnd:function(c){var a=this,b=a.getSplitter();b.removeCls(b.baseCls+"-active");a.performResize(c,a.getOffset("dragTarget"))},onDrag:function(g){var c=this,h=c.getOffset("dragTarget"),d=c.getSplitter(),b=d.getEl(),a=d.orientation;if(a==="vertical"){b.setX(c.startRegion.left+h[0])}else{b.setY(c.startRegion.top+h[1])}},getSplitter:function(){return this.splitter}});Ext.define("Ext.resizer.BorderSplitterTracker",{extend:"Ext.resizer.SplitterTracker",requires:["Ext.util.Region"],getPrevCmp:null,getNextCmp:null,calculateConstrainRegion:function(){var y=this,a=y.splitter,o=a.collapseTarget,d=a.defaultSplitMin,h=a.vertical?"Width":"Height",c="min"+h,u="max"+h,j="get"+h,t=a.neighbors,e=t.length,n=o.el.getBox(),g=n.x,p=n.y,x=n.right,k=n.bottom,r=a.vertical?(x-g):(k-p),w,l,m,v,s,q,b;m=(o[c]||Math.min(r,d))-r;v=o[u];if(!v){v=1000000000}else{v-=r}b=r;for(w=0;w<e;++w){l=t[w];r=l[j]();s=r-l[u];q=r-(l[c]||Math.min(r,d));if(!isNaN(s)){if(m<s){m=s}}if(v>q){v=q}}if(v-m<2){return null}n=new Ext.util.Region(p,x,k,g);y.constraintAdjusters[a.collapseDirection](n,m,v,a);y.dragInfo={minRange:m,maxRange:v,targetSize:b};return n},constraintAdjusters:{left:function(c,a,b,d){c[0]=c.x=c.left=c.right+a;c.right+=b+d.getWidth()},top:function(c,a,b,d){c[1]=c.y=c.top=c.bottom+a;c.bottom+=b+d.getHeight()},bottom:function(c,a,b,d){c.bottom=c.top-a;c.top-=b+d.getHeight()},right:function(c,a,b,d){c.right=c.left-a;c.left-=b+d.getWidth()}},onBeforeStart:function(h){var k=this,b=k.splitter,a=b.collapseTarget,m=b.neighbors,d=k.getSplitter().collapseEl,j=h.getTarget(),c=m.length,g,l;if(d&&j===b.collapseEl.dom){return false}if(a.collapsed){return false}for(g=0;g<c;++g){l=m[g];if(l.collapsed&&l.isHorz===a.isHorz){return false}}if(!(k.constrainTo=k.calculateConstrainRegion())){return false}k.createDragOverlay();return true},performResize:function(j,i){var k=this,b=k.splitter,h=b.collapseDirection,a=b.collapseTarget,g=k.splitAdjusters[b.vertical?"horz":"vert"],l=i[g.index],d=k.dragInfo,c;if(h=="right"||h=="bottom"){l=-l}l=Math.min(Math.max(d.minRange,l),d.maxRange);if(l){(c=b.ownerCt).suspendLayouts();g.adjustTarget(a,d.targetSize,l);c.resumeLayouts(true)}},splitAdjusters:{horz:{index:0,adjustTarget:function(b,a,c){b.flex=null;b.setSize(a+c)}},vert:{index:1,adjustTarget:function(b,a,c){b.flex=null;b.setSize(undefined,a+c)}}}});Ext.define("Ext.resizer.Handle",{extend:"Ext.Component",handleCls:"",baseHandleCls:Ext.baseCSSPrefix+"resizable-handle",region:"",beforeRender:function(){var a=this;a.callParent();a.addCls(a.baseHandleCls,a.baseHandleCls+"-"+a.region,a.handleCls)},onRender:function(){this.callParent(arguments);this.el.unselectable()}});Ext.define("Ext.resizer.ResizeTracker",{extend:"Ext.dd.DragTracker",dynamic:true,preserveRatio:false,constrainTo:null,proxyCls:Ext.baseCSSPrefix+"resizable-proxy",constructor:function(b){var d=this,c,a,e;if(!b.el){if(b.target.isComponent){d.el=b.target.getEl()}else{d.el=b.target}}this.callParent(arguments);if(d.preserveRatio&&d.minWidth&&d.minHeight){c=d.minWidth/d.el.getWidth();a=d.minHeight/d.el.getHeight();if(a>c){d.minWidth=d.el.getWidth()*a}else{d.minHeight=d.el.getHeight()*c}}if(d.throttle){e=Ext.Function.createThrottled(function(){Ext.resizer.ResizeTracker.prototype.resize.apply(d,arguments)},d.throttle);d.resize=function(h,i,g){if(g){Ext.resizer.ResizeTracker.prototype.resize.apply(d,arguments)}else{e.apply(null,arguments)}}}},onBeforeStart:function(a){this.startBox=this.el.getBox()},getDynamicTarget:function(){var a=this,b=a.target;if(a.dynamic){return b}else{if(!a.proxy){a.proxy=a.createProxy(b)}}a.proxy.show();return a.proxy},createProxy:function(c){var b,a=this.proxyCls,d;if(c.isComponent){b=c.getProxy().addCls(a)}else{d=Ext.getBody();if(Ext.scopeResetCSS){d=Ext.getBody().createChild({cls:Ext.resetCls})}b=c.createProxy({tag:"div",cls:a,id:c.id+"-rzproxy"},d)}b.removeCls(Ext.baseCSSPrefix+"proxy-el");return b},onStart:function(a){this.activeResizeHandle=Ext.get(this.getDragTarget().id);if(!this.dynamic){this.resize(this.startBox,{horizontal:"none",vertical:"none"})}},onDrag:function(a){if(this.dynamic||this.proxy){this.updateDimensions(a)}},updateDimensions:function(s,m){var t=this,c=t.activeResizeHandle.region,g=t.getOffset(t.constrainTo?"dragTarget":null),k=t.startBox,h,p=0,u=0,j,q,a=0,w=0,v,n=g[0]<0?"right":"left",r=g[1]<0?"down":"up",i,b,d,o,l;switch(c){case"south":u=g[1];b=2;break;case"north":u=-g[1];w=-u;b=2;break;case"east":p=g[0];b=1;break;case"west":p=-g[0];a=-p;b=1;break;case"northeast":u=-g[1];w=-u;p=g[0];i=[k.x,k.y+k.height];b=3;break;case"southeast":u=g[1];p=g[0];i=[k.x,k.y];b=3;break;case"southwest":p=-g[0];a=-p;u=g[1];i=[k.x+k.width,k.y];b=3;break;case"northwest":u=-g[1];w=-u;p=-g[0];a=-p;i=[k.x+k.width,k.y+k.height];b=3;break}d={width:k.width+p,height:k.height+u,x:k.x+a,y:k.y+w};j=Ext.Number.snap(d.width,t.widthIncrement);q=Ext.Number.snap(d.height,t.heightIncrement);if(j!=d.width||q!=d.height){switch(c){case"northeast":d.y-=q-d.height;break;case"north":d.y-=q-d.height;break;case"southwest":d.x-=j-d.width;break;case"west":d.x-=j-d.width;break;case"northwest":d.x-=j-d.width;d.y-=q-d.height}d.width=j;d.height=q}if(d.width<t.minWidth||d.width>t.maxWidth){d.width=Ext.Number.constrain(d.width,t.minWidth,t.maxWidth);if(a){d.x=k.x+(k.width-d.width)}}else{t.lastX=d.x}if(d.height<t.minHeight||d.height>t.maxHeight){d.height=Ext.Number.constrain(d.height,t.minHeight,t.maxHeight);if(w){d.y=k.y+(k.height-d.height)}}else{t.lastY=d.y}if(t.preserveRatio||s.shiftKey){h=t.startBox.width/t.startBox.height;o=Math.min(Math.max(t.minHeight,d.width/h),t.maxHeight);l=Math.min(Math.max(t.minWidth,d.height*h),t.maxWidth);if(b==1){d.height=o}else{if(b==2){d.width=l}else{v=Math.abs(i[0]-this.lastXY[0])/Math.abs(i[1]-this.lastXY[1]);if(v>h){d.height=o}else{d.width=l}if(c=="northeast"){d.y=k.y-(d.height-k.height)}else{if(c=="northwest"){d.y=k.y-(d.height-k.height);d.x=k.x-(d.width-k.width)}else{if(c=="southwest"){d.x=k.x-(d.width-k.width)}}}}}}if(u===0){r="none"}if(p===0){n="none"}t.resize(d,{horizontal:n,vertical:r},m)},getResizeTarget:function(a){return a?this.target:this.getDynamicTarget()},resize:function(b,d,a){var c=this.getResizeTarget(a);if(c.isComponent){c.setSize(b.width,b.height);if(c.floating){c.setPagePosition(b.x,b.y)}}else{c.setBox(b)}c=this.originalTarget;if(c&&(this.dynamic||a)){if(c.isComponent){c.setSize(b.width,b.height);if(c.floating){c.setPagePosition(b.x,b.y)}}else{c.setBox(b)}}},onEnd:function(a){this.updateDimensions(a,true);if(this.proxy){this.proxy.hide()}}});Ext.define("Ext.resizer.Resizer",{mixins:{observable:"Ext.util.Observable"},uses:["Ext.resizer.ResizeTracker","Ext.Component"],alternateClassName:"Ext.Resizable",handleCls:Ext.baseCSSPrefix+"resizable-handle",pinnedCls:Ext.baseCSSPrefix+"resizable-pinned",overCls:Ext.baseCSSPrefix+"resizable-over",wrapCls:Ext.baseCSSPrefix+"resizable-wrap",dynamic:true,handles:"s e se",height:null,width:null,heightIncrement:0,widthIncrement:0,minHeight:20,minWidth:20,maxHeight:10000,maxWidth:10000,pinned:false,preserveRatio:false,transparent:false,possiblePositions:{n:"north",s:"south",e:"east",w:"west",se:"southeast",sw:"southwest",nw:"northwest",ne:"northeast"},constructor:function(b){var k=this,j,o,q,p=k.handles,c,n,g,d=0,m,l=[],h,a,e;k.addEvents("beforeresize","resizedrag","resize");if(Ext.isString(b)||Ext.isElement(b)||b.dom){j=b;b=arguments[1]||{};b.target=j}k.mixins.observable.constructor.call(k,b);j=k.target;if(j){if(j.isComponent){k.el=j.getEl();if(j.minWidth){k.minWidth=j.minWidth}if(j.minHeight){k.minHeight=j.minHeight}if(j.maxWidth){k.maxWidth=j.maxWidth}if(j.maxHeight){k.maxHeight=j.maxHeight}if(j.floating){if(!k.hasOwnProperty("handles")){k.handles="n ne e se s sw w nw"}}}else{k.el=k.target=Ext.get(j)}}else{k.target=k.el=Ext.get(k.el)}q=k.el.dom.tagName.toUpperCase();if(q=="TEXTAREA"||q=="IMG"||q=="TABLE"){k.originalTarget=k.target;o=k.el;e=o.getBox();k.target=k.el=k.el.wrap({cls:k.wrapCls,id:k.el.id+"-rzwrap",style:o.getStyles("margin-top","margin-bottom")});k.el.setPositioning(o.getPositioning());o.clearPositioning();k.el.setBox(e);o.setStyle("position","absolute")}k.el.position();if(k.pinned){k.el.addCls(k.pinnedCls)}k.resizeTracker=new Ext.resizer.ResizeTracker({disabled:k.disabled,target:k.target,constrainTo:k.constrainTo,overCls:k.overCls,throttle:k.throttle,originalTarget:k.originalTarget,delegate:"."+k.handleCls,dynamic:k.dynamic,preserveRatio:k.preserveRatio,heightIncrement:k.heightIncrement,widthIncrement:k.widthIncrement,minHeight:k.minHeight,maxHeight:k.maxHeight,minWidth:k.minWidth,maxWidth:k.maxWidth});k.resizeTracker.on({mousedown:k.onBeforeResize,drag:k.onResize,dragend:k.onResizeEnd,scope:k});if(k.handles=="all"){k.handles="n s e w ne nw se sw"}p=k.handles=k.handles.split(/ |\s*?[,;]\s*?/);n=k.possiblePositions;g=p.length;c=k.handleCls+" "+(k.target.isComponent?(k.target.baseCls+"-handle "):"")+k.handleCls+"-";h=Ext.isIE6?' style="height:'+k.el.getHeight()+'px"':"";for(;d<g;d++){if(p[d]&&n[p[d]]){m=n[p[d]];if(m==="east"||m==="west"){a=h}else{a=""}l.push('<div id="'+k.el.id+"-"+m+'-handle" class="'+c+m+" "+Ext.baseCSSPrefix+'unselectable"'+a+"></div>")}}Ext.DomHelper.append(k.el,l.join(""));for(d=0;d<g;d++){if(p[d]&&n[p[d]]){m=n[p[d]];k[m]=k.el.getById(k.el.id+"-"+m+"-handle");k[m].region=m;k[m].unselectable();if(k.transparent){k[m].setOpacity(0)}}}if(Ext.isNumber(k.width)){k.width=Ext.Number.constrain(k.width,k.minWidth,k.maxWidth)}if(Ext.isNumber(k.height)){k.height=Ext.Number.constrain(k.height,k.minHeight,k.maxHeight)}if(k.width!==null||k.height!==null){if(k.originalTarget){k.originalTarget.setWidth(k.width);k.originalTarget.setHeight(k.height)}k.resizeTo(k.width,k.height)}k.forceHandlesHeight()},disable:function(){this.resizeTracker.disable()},enable:function(){this.resizeTracker.enable()},onBeforeResize:function(b,c){var a=this.el.getBox();return this.fireEvent("beforeresize",this,a.width,a.height,c)},onResize:function(c,d){var b=this,a=b.el.getBox();b.forceHandlesHeight();return b.fireEvent("resizedrag",b,a.width,a.height,d)},onResizeEnd:function(c,d){var b=this,a=b.el.getBox();b.forceHandlesHeight();return b.fireEvent("resize",b,a.width,a.height,d)},resizeTo:function(b,a){var c=this;c.target.setSize(b,a);c.fireEvent("resize",c,b,a,null)},getEl:function(){return this.el},getTarget:function(){return this.target},destroy:function(){var d=0,c=this.handles,a=c.length,b=this.possiblePositions;for(;d<a;d++){this[b[c[d]]].remove()}},forceHandlesHeight:function(){var a=this,b;if(Ext.isIE6){b=a.east;if(b){b.setHeight(a.el.getHeight())}b=a.west;if(b){b.setHeight(a.el.getHeight())}a.el.repaint()}}});Ext.define("Ext.selection.CellModel",{extend:"Ext.selection.Model",alias:"selection.cellmodel",requires:["Ext.util.KeyNav"],isCellModel:true,enableKeyNav:true,preventWrap:false,noSelection:{row:-1,column:-1},constructor:function(){this.addEvents("deselect","select");this.callParent(arguments)},bindComponent:function(a){var c=this,b=a.ownerCt;c.primaryView=a;c.views=c.views||[];c.views.push(a);c.bindStore(a.getStore(),true);a.on({cellmousedown:c.onMouseDown,refresh:c.onViewRefresh,scope:c});if(b.optimizedColumnMove!==false){b.on("columnmove",c.onColumnMove,c)}if(c.enableKeyNav){c.initKeyNav(a)}},initKeyNav:function(a){var b=this;if(!a.rendered){a.on("render",Ext.Function.bind(b.initKeyNav,b,[a],0),b,{single:true});return}a.el.set({tabIndex:-1});b.keyNav=new Ext.util.KeyNav({target:a.el,ignoreInputFields:true,up:b.onKeyUp,down:b.onKeyDown,right:b.onKeyRight,left:b.onKeyLeft,tab:b.onKeyTab,scope:b})},getHeaderCt:function(){var b=this.getCurrentPosition(),a=b?b.view:this.primaryView;return a.headerCt},onKeyUp:function(b,a){this.keyNavigation=true;this.move("up",b);this.keyNavigation=false},onKeyDown:function(b,a){this.keyNavigation=true;this.move("down",b);this.keyNavigation=false},onKeyLeft:function(b,a){this.keyNavigation=true;this.move("left",b);this.keyNavigation=false},onKeyRight:function(b,a){this.keyNavigation=true;this.move("right",b);this.keyNavigation=false},move:function(a,d){var c=this,g=c.getCurrentPosition(),b=g.view.walkCells(g,a,d,c.preventWrap);if(b){b.view=g.view;return c.setCurrentPosition(b)}},getCurrentPosition:function(){return this.selection},setCurrentPosition:function(b){var a=this;a.lastSelection=a.selection;if(a.selection){a.onCellDeselect(a.selection)}if(b){a.nextSelection=new a.Selection(a);a.nextSelection.setPosition(b);a.onCellSelect(a.nextSelection);return a.selection=a.nextSelection}},onStoreRemove:function(b,a,c){var d=this,e=d.getCurrentPosition();d.callParent(arguments);if(e){if(e.row==c){if(c<b.getCount()-1){e.setPosition(c,e.column);d.setCurrentPosition(e)}else{delete d.selection}}else{if(c<e.row){e.setPosition(e.row-1,e.column);d.setCurrentPosition(e)}}}},onMouseDown:function(c,a,d,b,h,i,g){this.setCurrentPosition({view:c,row:i,column:d})},onCellSelect:function(a,b){if(a&&a.row!==undefined&&a.row>-1){this.doSelect(a.view.getStore().getAt(a.row),false,b)}},onCellDeselect:function(a,b){if(a&&a.row!==undefined){this.doDeselect(a.view.getStore().getAt(a.row),b)}},onSelectChange:function(b,e,d,h){var g=this,i,c,a;if(e){i=g.nextSelection;c="select"}else{i=g.lastSelection||g.noSelection;c="deselect"}a=i.view||g.primaryView;if((d||g.fireEvent("before"+c,g,b,i.row,i.column))!==false&&h()!==false){if(e){a.onCellSelect(i);a.onCellFocus(i)}else{a.onCellDeselect(i);delete g.selection}if(!d){g.fireEvent(c,g,b,i.row,i.column)}}},onKeyTab:function(d,b){var c=this,a=c.getCurrentPosition().view.editingPlugin;if(a&&c.wasEditing){c.onEditorTab(a,d)}else{c.move(d.shiftKey?"left":"right",d)}},onEditorTab:function(b,g){var c=this,d=g.shiftKey?"left":"right",a=c.move(d,g);if(a){if(b.startEditByPosition(a)){c.wasEditing=false}else{c.wasEditing=true;if(!a.columnHeader.dataIndex){c.onEditorTab(b,g)}}}},refresh:function(){var b=this.getCurrentPosition(),a;if(b&&(a=this.store.indexOf(this.selected.last()))!==-1){b.row=a}},onColumnMove:function(d,e,b,c){var a=d.up("tablepanel");if(a){this.onViewRefresh(a.view)}},onViewRefresh:function(b){var c=this,g=c.getCurrentPosition(),e=b.headerCt,a,d;if(g&&g.view===b){a=g.record;d=g.columnHeader;if(!d.isDescendantOf(e)){d=e.queryById(d.id)||e.down('[text="'+d.text+'"]')||e.down('[dataIndex="'+d.dataIndex+'"]')}if(d&&(b.store.indexOfId(a.getId())!==-1)){c.setCurrentPosition({row:a,column:d,view:b})}}},selectByPosition:function(a){this.setCurrentPosition(a)}},function(){var a=this.prototype.Selection=function(b){this.model=b};a.prototype.setPosition=function(e,c){var d=this,b;if(arguments.length===1){if(e.view){d.view=b=e.view}c=e.column;e=e.row}if(!b){d.view=b=d.model.primaryView}if(typeof e==="number"){d.row=e;d.record=b.store.getAt(e)}else{if(e.isModel){d.record=e;d.row=b.indexOf(e)}else{if(e.tagName){d.record=b.getRecord(e);d.row=b.indexOf(d.record)}}}if(typeof c==="number"){d.column=c;d.columnHeader=b.getHeaderAtIndex(c)}else{d.columnHeader=c;d.column=c.getIndex()}return d}});Ext.define("Ext.selection.RowModel",{extend:"Ext.selection.Model",alias:"selection.rowmodel",requires:["Ext.util.KeyNav"],deltaScroll:5,enableKeyNav:true,ignoreRightMouseSelection:false,constructor:function(){this.addEvents("beforedeselect","beforeselect","deselect","select");this.views=[];this.callParent(arguments)},bindComponent:function(a){var b=this;b.views=b.views||[];b.views.push(a);b.bindStore(a.getStore(),true);a.on({itemmousedown:b.onRowMouseDown,scope:b});if(b.enableKeyNav){b.initKeyNav(a)}},initKeyNav:function(a){var b=this;if(!a.rendered){a.on("render",Ext.Function.bind(b.initKeyNav,b,[a],0),b,{single:true});return}a.el.set({tabIndex:-1});b.keyNav=new Ext.util.KeyNav({target:a,ignoreInputFields:true,eventName:"itemkeydown",processEvent:function(d,c,h,e,g){g.record=c;g.recordIndex=e;return g},up:b.onKeyUp,down:b.onKeyDown,right:b.onKeyRight,left:b.onKeyLeft,pageDown:b.onKeyPageDown,pageUp:b.onKeyPageUp,home:b.onKeyHome,end:b.onKeyEnd,space:b.onKeySpace,enter:b.onKeyEnter,scope:b})},getRowsVisible:function(){var e=false,a=this.views[0],d=a.getNode(0),b,c;if(d){b=Ext.fly(d).getHeight();c=a.el.getHeight();e=Math.floor(c/b)}return e},onKeyEnd:function(c){var b=this,a=b.store.getAt(b.store.getCount()-1);if(a){if(c.shiftKey){b.selectRange(a,b.lastFocused||0);b.setLastFocused(a)}else{if(c.ctrlKey){b.setLastFocused(a)}else{b.doSelect(a)}}}},onKeyHome:function(b){var a=this,c=a.store.getAt(0);if(c){if(b.shiftKey){a.selectRange(c,a.lastFocused||0);a.setLastFocused(c)}else{if(b.ctrlKey){a.setLastFocused(c)}else{a.doSelect(c,false)}}}},onKeyPageUp:function(g){var d=this,h=d.getRowsVisible(),b,c,a;if(h){b=g.recordIndex;c=b-h;if(c<0){c=0}a=d.store.getAt(c);if(g.shiftKey){d.selectRange(a,g.record,g.ctrlKey,"up");d.setLastFocused(a)}else{if(g.ctrlKey){g.preventDefault();d.setLastFocused(a)}else{d.doSelect(a)}}}},onKeyPageDown:function(g){var c=this,h=c.getRowsVisible(),a,d,b;if(h){a=g.recordIndex;d=a+h;if(d>=c.store.getCount()){d=c.store.getCount()-1}b=c.store.getAt(d);if(g.shiftKey){c.selectRange(b,g.record,g.ctrlKey,"down");c.setLastFocused(b)}else{if(g.ctrlKey){g.preventDefault();c.setLastFocused(b)}else{c.doSelect(b)}}}},onKeySpace:function(c){var b=this,a=b.lastFocused;if(a){if(b.isSelected(a)){b.doDeselect(a,false)}else{b.doSelect(a,true)}}},onKeyEnter:Ext.emptyFn,onKeyUp:function(d){var c=this,a=c.store.indexOf(c.lastFocused),b;if(a>0){b=c.store.getAt(a-1);if(d.shiftKey&&c.lastFocused){if(c.isSelected(c.lastFocused)&&c.isSelected(b)){c.doDeselect(c.lastFocused,true);c.setLastFocused(b)}else{if(!c.isSelected(c.lastFocused)){c.doSelect(c.lastFocused,true);c.doSelect(b,true)}else{c.doSelect(b,true)}}}else{if(d.ctrlKey){c.setLastFocused(b)}else{c.doSelect(b)}}}},onKeyDown:function(d){var c=this,a=c.store.indexOf(c.lastFocused),b;if(a+1<c.store.getCount()){b=c.store.getAt(a+1);if(c.selected.getCount()===0){if(!d.ctrlKey){c.doSelect(b)}else{c.setLastFocused(b)}}else{if(d.shiftKey&&c.lastFocused){if(c.isSelected(c.lastFocused)&&c.isSelected(b)){c.doDeselect(c.lastFocused,true);c.setLastFocused(b)}else{if(!c.isSelected(c.lastFocused)){c.doSelect(c.lastFocused,true);c.doSelect(b,true)}else{c.doSelect(b,true)}}}else{if(d.ctrlKey){c.setLastFocused(b)}else{c.doSelect(b)}}}}},scrollByDeltaX:function(d){var a=this.views[0],c=a.up(),b=c.horizontalScroller;if(b){b.scrollByDeltaX(d)}},onKeyLeft:function(a){this.scrollByDeltaX(-this.deltaScroll)},onKeyRight:function(a){this.scrollByDeltaX(this.deltaScroll)},onRowMouseDown:function(b,a,d,c,g){if(!this.allowRightMouseSelection(g)){return}if(g.button===0||!this.isSelected(a)){this.selectWithEvent(a,g)}},allowRightMouseSelection:function(a){var b=this.ignoreRightMouseSelection&&a.button!==0;if(b){b=this.hasSelection()}return !b},onSelectChange:function(g,c,l,a){var j=this,m=j.views,d=m.length,k=j.store,b=k.indexOf(g),h=c?"select":"deselect",e=0;if((l||j.fireEvent("before"+h,j,g,b))!==false&&a()!==false){for(;e<d;e++){if(c){m[e].onRowSelect(b,l)}else{m[e].onRowDeselect(b,l)}}if(!l){j.fireEvent(h,j,g,b)}}},onLastFocusChanged:function(j,d,b){var a=this.views,h=a.length,c=this.store,g,e=0;if(j){g=c.indexOf(j);if(g!=-1){for(;e<h;e++){a[e].onRowFocus(g,false)}}}if(d){g=c.indexOf(d);if(g!=-1){for(e=0;e<h;e++){a[e].onRowFocus(g,true,b)}}}this.callParent()},onEditorTab:function(d,i){var g=this,c=g.views[0],b=d.getActiveRecord(),j=d.getActiveColumn(),a=c.getPosition(b,j),h=i.shiftKey?"left":"right";do{a=c.walkCells(a,h,i,g.preventWrap)}while(a&&!c.headerCt.getHeaderAtIndex(a.column).getEditor());if(a){d.startEditByPosition(a)}},getCurrentPosition:function(){var a=this.selected.items[0];if(a){return{row:this.store.indexOf(a),column:0}}},selectByPosition:function(a){var b=this.store.getAt(a.row);this.select(b)},selectNext:function(h,c){var g=this,b=g.store,e=g.getSelection(),a=e[e.length-1],d=b.indexOf(a)+1,i;if(d===b.getCount()||d===0){i=false}else{g.doSelect(d,h,c);i=true}return i},selectPrevious:function(g,b){var e=this,d=e.getSelection(),a=d[0],c=e.store.indexOf(a)-1,h;if(c<0){h=false}else{e.doSelect(c,g,b);h=true}return h}});Ext.define("Ext.selection.CheckboxModel",{alias:"selection.checkboxmodel",extend:"Ext.selection.RowModel",mode:"MULTI",injectCheckbox:0,checkOnly:false,showHeaderCheckbox:true,headerWidth:24,checkerOnCls:Ext.baseCSSPrefix+"grid-hd-checker-on",refreshOnRemove:true,beforeViewRender:function(a){var b=this;b.callParent(arguments);if(!b.hasLockedHeader()||a.headerCt.lockedCt){if(b.showHeaderCheckbox!==false){a.headerCt.on("headerclick",b.onHeaderClick,b)}b.addCheckbox(a,true);b.mon(a.ownerCt,"reconfigure",b.onReconfigure,b)}},bindComponent:function(a){var b=this;b.sortable=false;b.callParent(arguments)},hasLockedHeader:function(){var a=this.views,c=a.length,b;for(b=0;b<c;b++){if(a[b].headerCt.lockedCt){return true}}return false},addCheckbox:function(a,b){var c=this,d=c.injectCheckbox,e=a.headerCt;if(d!==false){if(d=="first"){d=0}else{if(d=="last"){d=e.getColumnCount()}}Ext.suspendLayouts();e.add(d,c.getHeaderConfig());Ext.resumeLayouts()}if(b!==true){a.refresh()}},onReconfigure:function(c,a,b){if(b){this.addCheckbox(this.views[0])}},toggleUiHeader:function(d){var a=this.views[0],c=a.headerCt,b=c.child("gridcolumn[isCheckerHd]");if(b){if(d){b.el.addCls(this.checkerOnCls)}else{b.el.removeCls(this.checkerOnCls)}}},onHeaderClick:function(c,g,b){if(g.isCheckerHd){b.stopEvent();var a=this,d=g.el.hasCls(Ext.baseCSSPrefix+"grid-hd-checker-on");a.preventFocus=true;if(d){a.deselectAll()}else{a.selectAll()}delete a.preventFocus}},getHeaderConfig:function(){var a=this,b=a.showHeaderCheckbox!==false;return{isCheckerHd:b,text:"&#160;",width:a.headerWidth,sortable:false,draggable:false,resizable:false,hideable:false,menuDisabled:true,dataIndex:"",cls:b?Ext.baseCSSPrefix+"column-header-checkbox ":"",renderer:Ext.Function.bind(a.renderer,a),editRenderer:a.editRenderer||a.renderEmpty,locked:a.hasLockedHeader()}},renderEmpty:function(){return"&#160;"},renderer:function(h,c,b,i,e,d,a){var g=Ext.baseCSSPrefix;c.tdCls=g+"grid-cell-special "+g+"grid-cell-row-checker";return'<div class="'+g+'grid-row-checker">&#160;</div>'},onRowMouseDown:function(b,a,h,d,i){b.el.focus();var g=this,c=i.getTarget("."+Ext.baseCSSPrefix+"grid-row-checker"),j;if(!g.allowRightMouseSelection(i)){return}if(g.checkOnly&&!c){return}if(c){j=g.getSelectionMode();if(j!=="SINGLE"){g.setSelectionMode("SIMPLE")}g.selectWithEvent(a,i);g.setSelectionMode(j)}else{g.selectWithEvent(a,i)}},onSelectChange:function(){var a=this;a.callParent(arguments);a.updateHeaderState()},onStoreLoad:function(){var a=this;a.callParent(arguments);a.updateHeaderState()},updateHeaderState:function(){var a=this.selected.getCount()===this.store.getCount();this.toggleUiHeader(a)}});Ext.define("Ext.selection.TreeModel",{extend:"Ext.selection.RowModel",alias:"selection.treemodel",pruneRemoved:false,onKeyRight:function(d,b){var c=this.getLastFocused(),a=this.view;if(c){if(c.isExpanded()){this.onKeyDown(d,b)}else{if(c.isExpandable()){a.expand(c)}}}},onKeyLeft:function(i,d){var h=this.getLastFocused(),c=this.view,b=c.getSelectionModel(),a,g;if(h){a=h.parentNode;if(h.isExpanded()){c.collapse(h)}else{if(a&&!a.isRoot()){if(i.shiftKey){b.selectRange(a,h,i.ctrlKey,"up");b.setLastFocused(a)}else{if(i.ctrlKey){b.setLastFocused(a)}else{b.select(a)}}}}}},onKeySpace:function(b,a){this.toggleCheck(b)},onKeyEnter:function(b,a){this.toggleCheck(b)},toggleCheck:function(b){b.stopEvent();var a=this.getLastSelected();if(a){this.view.onCheckChange(a)}}});Ext.define("Ext.slider.Thumb",{requires:["Ext.dd.DragTracker","Ext.util.Format"],topZIndex:10000,constructor:function(a){var b=this;Ext.apply(b,a||{},{cls:Ext.baseCSSPrefix+"slider-thumb",constrain:false});b.callParent([a])},render:function(){var a=this;a.el=a.slider.innerEl.insertFirst(a.getElConfig());a.onRender()},onRender:function(){if(this.disabled){this.disable()}this.initEvents()},getElConfig:function(){var c=this,b=c.slider,a={};a[b.vertical?"bottom":"left"]=b.calculateThumbPosition(b.normalizeValue(c.value))+"%";return{style:a,id:this.id,cls:this.cls}},move:function(c,b){var d=this.el,a=this.slider.vertical?"bottom":"left",g,e;c+="%";if(!b){d.dom.style[a]=c}else{g={};g[a]=c;if(!Ext.supports.GetPositionPercentage){e={};e[a]=d.dom.style[a]}new Ext.fx.Anim({target:d,duration:350,from:e,to:g})}},bringToFront:function(){this.el.setStyle("zIndex",this.topZIndex)},sendToBack:function(){this.el.setStyle("zIndex","")},enable:function(){var a=this;a.disabled=false;if(a.el){a.el.removeCls(a.slider.disabledCls)}},disable:function(){var a=this;a.disabled=true;if(a.el){a.el.addCls(a.slider.disabledCls)}},initEvents:function(){var b=this,a=b.el;b.tracker=new Ext.dd.DragTracker({onBeforeStart:Ext.Function.bind(b.onBeforeDragStart,b),onStart:Ext.Function.bind(b.onDragStart,b),onDrag:Ext.Function.bind(b.onDrag,b),onEnd:Ext.Function.bind(b.onDragEnd,b),tolerance:3,autoStart:300,overCls:Ext.baseCSSPrefix+"slider-thumb-over"});b.tracker.initEl(a)},onBeforeDragStart:function(a){if(this.disabled){return false}else{this.slider.promoteThumb(this);return true}},onDragStart:function(b){var a=this;a.el.addCls(Ext.baseCSSPrefix+"slider-thumb-drag");a.dragging=a.slider.dragging=true;a.dragStartValue=a.value;a.slider.fireEvent("dragstart",a.slider,b,a)},onDrag:function(h){var d=this,c=d.slider,b=d.index,g=d.getValueFromTracker(),a,i;if(g!==undefined){if(d.constrain){a=c.thumbs[b+1];i=c.thumbs[b-1];if(i!==undefined&&g<=i.value){g=i.value}if(a!==undefined&&g>=a.value){g=a.value}}c.setValue(b,g,false);c.fireEvent("drag",c,h,d)}},getValueFromTracker:function(){var a=this.slider,b=a.getTrackpoint(this.tracker.getXY());if(b!==undefined){return a.reversePixelValue(b)}},onDragEnd:function(d){var b=this,a=b.slider,c=b.value;b.el.removeCls(Ext.baseCSSPrefix+"slider-thumb-drag");b.dragging=a.dragging=false;a.fireEvent("dragend",a,d);if(b.dragStartValue!=c){a.fireEvent("changecomplete",a,c,b)}},destroy:function(){Ext.destroy(this.tracker)}});Ext.define("Ext.slider.Tip",{extend:"Ext.tip.Tip",minWidth:10,alias:"widget.slidertip",offsets:null,align:null,position:"",defaultVerticalPosition:"left",defaultHorizontalPosition:"top",isSliderTip:true,init:function(c){var b=this,d,a;if(!b.position){b.position=c.vertical?b.defaultVerticalPosition:b.defaultHorizontalPosition}switch(b.position){case"top":a=[0,-10];d="b-t?";break;case"bottom":a=[0,10];d="t-b?";break;case"left":a=[-10,0];d="r-l?";break;case"right":a=[10,0];d="l-r?"}if(!b.align){b.align=d}if(!b.offsets){b.offsets=a}c.on({scope:b,dragstart:b.onSlide,drag:b.onSlide,dragend:b.hide,destroy:b.destroy})},onSlide:function(c,d,a){var b=this;b.show();b.update(b.getText(a));b.el.alignTo(a.el,b.align,b.offsets)},getText:function(a){return String(a.value)}});Ext.define("Ext.slider.Multi",{extend:"Ext.form.field.Base",alias:"widget.multislider",alternateClassName:"Ext.slider.MultiSlider",requires:["Ext.slider.Thumb","Ext.slider.Tip","Ext.Number","Ext.util.Format","Ext.Template","Ext.layout.component.field.Slider"],childEls:["endEl","innerEl"],fieldSubTpl:['<div id="{id}" class="'+Ext.baseCSSPrefix+'slider {fieldCls} {vertical}" aria-valuemin="{minValue}" aria-valuemax="{maxValue}" aria-valuenow="{value}" aria-valuetext="{value}">','<div id="{cmpId}-endEl" class="'+Ext.baseCSSPrefix+'slider-end" role="presentation">','<div id="{cmpId}-innerEl" class="'+Ext.baseCSSPrefix+'slider-inner" role="presentation">',"{%this.renderThumbs(out, values)%}","</div>","</div>","</div>",{renderThumbs:function(g,e){var j=e.$comp,h=0,c=j.thumbs,b=c.length,d,a;for(;h<b;h++){d=c[h];a=d.getElConfig();a.id=j.id+"-thumb-"+h;Ext.DomHelper.generateMarkup(a,g)}},disableFormats:true}],vertical:false,minValue:0,maxValue:100,decimalPrecision:0,keyIncrement:1,increment:0,clickRange:[5,15],clickToChange:true,animate:true,dragging:false,constrainThumbs:true,componentLayout:"sliderfield",useTips:true,tipText:null,ariaRole:"slider",initValue:function(){var e=this,c=Ext.value,b=c(e.values,[c(e.value,c(e.minValue,0))]),d=0,a=b.length;e.originalValue=b;for(;d<a;d++){e.addThumb(b[d])}},initComponent:function(){var e=this,c,d,g,b,a;e.thumbs=[];e.keyIncrement=Math.max(e.increment,e.keyIncrement);e.addEvents("beforechange","change","changecomplete","dragstart","drag","dragend");if(e.increment){e.maxValue=Ext.Number.snapInRange(e.maxValue,e.increment,e.minValue);e.value=e.normalizeValue(e.value)}e.callParent();if(e.useTips){if(Ext.isObject(e.useTips)){c=Ext.apply({},e.useTips)}else{c=e.tipText?{getText:e.tipText}:{}}a=e.plugins=e.plugins||[];b=a.length;for(g=0;g<b;g++){if(a[g].isSliderTip){d=true;break}}if(!d){e.plugins.push(new Ext.slider.Tip(c))}}},addThumb:function(c){var b=this,a=new Ext.slider.Thumb({ownerCt:b,ownerLayout:b.getComponentLayout(),value:c,slider:b,index:b.thumbs.length,constrain:b.constrainThumbs,disabled:!!b.readOnly});b.thumbs.push(a);if(b.rendered){a.render()}return a},promoteThumb:function(c){var a=this.thumbs,e=a.length,g,b,d;for(d=0;d<e;d++){b=a[d];if(b==c){b.bringToFront()}else{b.sendToBack()}}},getSubTplData:function(){var a=this;return Ext.apply(a.callParent(),{$comp:a,vertical:a.vertical?Ext.baseCSSPrefix+"slider-vert":Ext.baseCSSPrefix+"slider-horz",minValue:a.minValue,maxValue:a.maxValue,value:a.value})},onRender:function(){var e=this,b=e.thumbs,a=b.length,d=0,c;e.callParent(arguments);for(d=0;d<a;d++){c=b[d];c.el=e.el.getById(e.id+"-thumb-"+d);c.onRender()}},initEvents:function(){var a=this;a.mon(a.el,{scope:a,mousedown:a.onMouseDown,keydown:a.onKeyDown})},getTrackpoint:function(g){var e=this,b,d,c=e.innerEl,a;if(e.vertical){d="top";a=c.getHeight()}else{d="left";a=c.getWidth()}b=Ext.Number.constrain(c.translatePoints(g)[d],0,a);return e.vertical?a-b:b},onMouseDown:function(j){var d=this,h=false,c=0,b=d.thumbs,a=b.length,g;if(d.disabled){return}for(;c<a;c++){h=h||j.target==b[c].el.dom}if(d.clickToChange&&!h){g=d.getTrackpoint(j.getXY());if(g!==undefined){d.onClickChange(g)}}d.focus()},onClickChange:function(d){var c=this,a,b;a=c.getNearest(d);if(!a.disabled){b=a.index;c.setValue(b,Ext.util.Format.round(c.reversePixelValue(d),c.decimalPrecision),undefined,true)}},getNearest:function(j){var k=this,g=k.reversePixelValue(j),l=(k.maxValue-k.minValue)+5,b=null,e=k.thumbs,c=0,d=e.length,a,m,h;for(;c<d;c++){a=k.thumbs[c];m=a.value;h=Math.abs(m-g);if(Math.abs(h<=l)){b=a;l=h}}return b},onKeyDown:function(c){var b=this,a,d;if(b.disabled||b.thumbs.length!==1){c.preventDefault();return}a=c.getKey();switch(a){case c.UP:case c.RIGHT:c.stopEvent();d=c.ctrlKey?b.maxValue:b.getValue(0)+b.keyIncrement;b.setValue(0,d,undefined,true);break;case c.DOWN:case c.LEFT:c.stopEvent();d=c.ctrlKey?b.minValue:b.getValue(0)-b.keyIncrement;b.setValue(0,d,undefined,true);break;default:c.preventDefault()}},normalizeValue:function(b){var c=this,d=Ext.Number,a=d[c.zeroBasedSnapping?"snap":"snapInRange"];b=a.call(d,b,c.increment,c.minValue,c.maxValue);b=Ext.util.Format.round(b,c.decimalPrecision);b=Ext.Number.constrain(b,c.minValue,c.maxValue);return b},setMinValue:function(g){var e=this,d=0,b=e.thumbs,a=b.length,c;e.minValue=g;if(e.rendered){e.inputEl.dom.setAttribute("aria-valuemin",g)}for(;d<a;++d){c=b[d];c.value=c.value<g?g:c.value}e.syncThumbs()},setMaxValue:function(g){var e=this,d=0,b=e.thumbs,a=b.length,c;e.maxValue=g;if(e.rendered){e.inputEl.dom.setAttribute("aria-valuemax",g)}for(;d<a;++d){c=b[d];c.value=c.value>g?g:c.value}e.syncThumbs()},setValue:function(c,g,b,e){var d=this,a=d.thumbs[c];g=d.normalizeValue(g);if(g!==a.value&&d.fireEvent("beforechange",d,g,a.value,a)!==false){a.value=g;if(d.rendered){d.inputEl.set({"aria-valuenow":g,"aria-valuetext":g});a.move(d.calculateThumbPosition(g),Ext.isDefined(b)?b!==false:d.animate);d.fireEvent("change",d,g,a);d.checkDirty();if(e){d.fireEvent("changecomplete",d,g,a)}}}},calculateThumbPosition:function(a){return(a-this.minValue)/(this.maxValue-this.minValue)*100},getRatio:function(){var b=this,a=this.vertical?this.innerEl.getHeight():this.innerEl.getWidth(),c=this.maxValue-this.minValue;return c===0?a:(a/c)},reversePixelValue:function(a){return this.minValue+(a/this.getRatio())},reversePercentageValue:function(a){return this.minValue+(this.maxValue-this.minValue)*(a/100)},onDisable:function(){var g=this,d=0,b=g.thumbs,a=b.length,c,e,h;g.callParent();for(;d<a;d++){c=b[d];e=c.el;c.disable();if(Ext.isIE){h=e.getXY();e.hide();g.innerEl.addCls(g.disabledCls).dom.disabled=true;if(!g.thumbHolder){g.thumbHolder=g.endEl.createChild({cls:Ext.baseCSSPrefix+"slider-thumb "+g.disabledCls})}g.thumbHolder.show().setXY(h)}}},onEnable:function(){var g=this,d=0,b=g.thumbs,a=b.length,c,e;this.callParent();for(;d<a;d++){c=b[d];e=c.el;c.enable();if(Ext.isIE){g.innerEl.removeCls(g.disabledCls).dom.disabled=false;if(g.thumbHolder){g.thumbHolder.hide()}e.show();g.syncThumbs()}}},syncThumbs:function(){if(this.rendered){var a=this.thumbs,c=a.length,b=0;for(;b<c;b++){a[b].move(this.calculateThumbPosition(a[b].value))}}},getValue:function(a){return Ext.isNumber(a)?this.thumbs[a].value:this.getValues()},getValues:function(){var c=[],d=0,b=this.thumbs,a=b.length;for(;d<a;d++){c.push(b[d].value)}return c},getSubmitValue:function(){var a=this;return(a.disabled||!a.submitValue)?null:a.getValue()},reset:function(){var e=this,b=[].concat(e.originalValue),c=0,d=b.length,g;for(;c<d;c++){g=b[c];e.setValue(c,g)}e.clearInvalid();delete e.wasValid},setReadOnly:function(e){var d=this,b=d.thumbs,a=b.length,c=0;d.callParent(arguments);e=d.readOnly;for(;c<a;++c){if(e){b[c].disable()}else{b[c].enable()}}},beforeDestroy:function(){var e=this,b=e.thumbs,d=0,a=b.length,c;Ext.destroy(e.innerEl,e.endEl,e.focusEl);for(;d<a;d++){c=b[d];Ext.destroy(c)}e.callParent()}});Ext.define("Ext.slider.Single",{extend:"Ext.slider.Multi",alias:["widget.slider","widget.sliderfield"],alternateClassName:["Ext.Slider","Ext.form.SliderField","Ext.slider.SingleSlider","Ext.slider.Slider"],getValue:function(){return this.callParent([0])},setValue:function(d,b){var c=arguments,a=c.length;if(a==1||(a<=3&&typeof c[1]!="number")){c=Ext.toArray(c);c.unshift(0)}return this.callParent(c)},getNearest:function(){return this.thumbs[0]}});Ext.define("Ext.state.CookieProvider",{extend:"Ext.state.Provider",constructor:function(a){var b=this;b.path="/";b.expires=new Date(new Date().getTime()+(1000*60*60*24*7));b.domain=null;b.secure=false;b.callParent(arguments);b.state=b.readCookies()},set:function(a,c){var b=this;if(typeof c=="undefined"||c===null){b.clear(a);return}b.setCookie(a,c);b.callParent(arguments)},clear:function(a){this.clearCookie(a);this.callParent(arguments)},readCookies:function(){var e={},j=document.cookie+";",d=/\s?(.*?)=(.*?);/g,i=this.prefix,a=i.length,h,b,g;while((h=d.exec(j))!=null){b=h[1];g=h[2];if(b&&b.substring(0,a)==i){e[b.substr(a)]=this.decodeValue(g)}}return e},setCookie:function(a,c){var b=this;document.cookie=b.prefix+a+"="+b.encodeValue(c)+((b.expires==null)?"":("; expires="+b.expires.toGMTString()))+((b.path==null)?"":("; path="+b.path))+((b.domain==null)?"":("; domain="+b.domain))+((b.secure==true)?"; secure":"")},clearCookie:function(a){var b=this;document.cookie=b.prefix+a+"=null; expires=Thu, 01-Jan-70 00:00:01 GMT"+((b.path==null)?"":("; path="+b.path))+((b.domain==null)?"":("; domain="+b.domain))+((b.secure==true)?"; secure":"")}});Ext.define("Ext.state.LocalStorageProvider",{extend:"Ext.state.Provider",alias:"state.localstorage",constructor:function(){var a=this;a.callParent(arguments);a.store=a.getStorageObject();a.state=a.readLocalStorage()},readLocalStorage:function(){var c=this.store,e=0,a=c.length,h=this.prefix,b=h.length,g={},d;for(;e<a;++e){d=c.key(e);if(d.substring(0,b)==h){g[d.substr(b)]=this.decodeValue(c.getItem(d))}}return g},set:function(a,c){var b=this;b.clear(a);if(typeof c=="undefined"||c===null){return}b.store.setItem(b.prefix+a,b.encodeValue(c));b.callParent(arguments)},clear:function(a){this.store.removeItem(this.prefix+a);this.callParent(arguments)},getStorageObject:function(){try{var a="localStorage" in window&&window.localStorage!==null;if(a){return window.localStorage}}catch(b){return false}}});Ext.define("Ext.tab.Tab",{extend:"Ext.button.Button",alias:"widget.tab",requires:["Ext.layout.component.Tab","Ext.util.KeyNav"],componentLayout:"tab",isTab:true,baseCls:Ext.baseCSSPrefix+"tab",activeCls:"active",closableCls:"closable",closable:true,closeText:"Close Tab",active:false,childEls:["closeEl"],scale:false,position:"top",initComponent:function(){var a=this;a.addEvents("activate","deactivate","beforeclose","close");a.callParent(arguments);if(a.card){a.setCard(a.card)}},getTemplateArgs:function(){var b=this,a=b.callParent();a.closable=b.closable;a.closeText=b.closeText;return a},beforeRender:function(){var b=this,a=b.up("tabbar"),c=b.up("tabpanel");b.callParent();b.addClsWithUI(b.position);b.syncClosableUI();if(!b.minWidth){b.minWidth=(a)?a.minTabWidth:b.minWidth;if(!b.minWidth&&c){b.minWidth=c.minTabWidth}if(b.minWidth&&b.iconCls){b.minWidth+=25}}if(!b.maxWidth){b.maxWidth=(a)?a.maxTabWidth:b.maxWidth;if(!b.maxWidth&&c){b.maxWidth=c.maxTabWidth}}},onRender:function(){var a=this;a.callParent(arguments);a.keyNav=new Ext.util.KeyNav(a.el,{enter:a.onEnterKey,del:a.onDeleteKey,scope:a})},enable:function(a){var b=this;b.callParent(arguments);b.removeClsWithUI(b.position+"-disabled");return b},disable:function(a){var b=this;b.callParent(arguments);b.addClsWithUI(b.position+"-disabled");return b},onDestroy:function(){var a=this;Ext.destroy(a.keyNav);delete a.keyNav;a.callParent(arguments)},setClosable:function(a){var b=this;a=(!arguments.length||!!a);if(b.closable!=a){b.closable=a;if(b.card){b.card.closable=a}b.syncClosableUI();if(b.rendered){b.syncClosableElements();b.updateLayout()}}},syncClosableElements:function(){var a=this,b=a.closeEl;if(a.closable){if(!b){a.closeEl=a.btnWrap.insertSibling({tag:"a",cls:a.baseCls+"-close-btn",href:"#",title:a.closeText},"after")}}else{if(b){b.remove();delete a.closeEl}}},syncClosableUI:function(){var b=this,a=[b.closableCls,b.closableCls+"-"+b.position];if(b.closable){b.addClsWithUI(a)}else{b.removeClsWithUI(a)}},setCard:function(a){var b=this;b.card=a;b.setText(b.title||a.title);b.setIconCls(b.iconCls||a.iconCls);b.setIcon(b.icon||a.icon)},onCloseClick:function(){var a=this;if(a.fireEvent("beforeclose",a)!==false){if(a.tabBar){if(a.tabBar.closeTab(a)===false){return}}else{a.fireClose()}}},fireClose:function(){this.fireEvent("close",this)},onEnterKey:function(b){var a=this;if(a.tabBar){a.tabBar.onClick(b,a.el)}},onDeleteKey:function(a){if(this.closable){this.onCloseClick()}},activate:function(b){var a=this;a.active=true;a.addClsWithUI([a.activeCls,a.position+"-"+a.activeCls]);if(b!==true){a.fireEvent("activate",a)}},deactivate:function(b){var a=this;a.active=false;a.removeClsWithUI([a.activeCls,a.position+"-"+a.activeCls]);if(b!==true){a.fireEvent("deactivate",a)}}});Ext.define("Ext.tab.Bar",{extend:"Ext.panel.Header",alias:"widget.tabbar",baseCls:Ext.baseCSSPrefix+"tab-bar",requires:["Ext.tab.Tab"],isTabBar:true,defaultType:"tab",plain:false,childEls:["body","strip"],renderTpl:['<div id="{id}-body" class="{baseCls}-body {bodyCls}<tpl if="ui"> {baseCls}-body-{ui}<tpl for="uiCls"> {parent.baseCls}-body-{parent.ui}-{.}</tpl></tpl>"<tpl if="bodyStyle"> style="{bodyStyle}"</tpl>>',"{%this.renderContainer(out,values)%}","</div>",'<div id="{id}-strip" class="{baseCls}-strip<tpl if="ui"> {baseCls}-strip-{ui}<tpl for="uiCls"> {parent.baseCls}-strip-{parent.ui}-{.}</tpl></tpl>"></div>'],initComponent:function(){var a=this;if(a.plain){a.setUI(a.ui+"-plain")}a.addClsWithUI(a.dock);a.addEvents("change");a.callParent(arguments);a.layout.align=(a.orientation=="vertical")?"left":"top";a.layout.overflowHandler=new Ext.layout.container.boxOverflow.Scroller(a.layout);a.remove(a.titleCmp);delete a.titleCmp;Ext.apply(a.renderData,{bodyCls:a.bodyCls})},getLayout:function(){var a=this;a.layout.type=(a.dock==="top"||a.dock==="bottom")?"hbox":"vbox";return a.callParent(arguments)},onAdd:function(a){a.position=this.dock;this.callParent(arguments)},onRemove:function(a){var b=this;if(a===b.previousTab){b.previousTab=null}b.callParent(arguments)},afterComponentLayout:function(a){this.callParent(arguments);this.strip.setWidth(a)},onClick:function(g,d){var c=this,i=g.getTarget("."+Ext.tab.Tab.prototype.baseCls),b=i&&Ext.getCmp(i.id),h=c.tabPanel,a=b&&b.closeEl&&(d===b.closeEl.dom);if(a){g.preventDefault()}if(b&&b.isDisabled&&!b.isDisabled()){if(b.closable&&a){b.onCloseClick()}else{if(h){h.setActiveTab(b.card)}else{c.setActiveTab(b)}b.focus()}}},closeTab:function(c){var d=this,b=c.card,e=d.tabPanel,a;if(b&&b.fireEvent("beforeclose",b)===false){return false}a=d.findNextActivatable(c);Ext.suspendLayouts();if(e&&b){delete c.ownerCt;b.fireEvent("close",b);e.remove(b);if(!e.getComponent(b)){c.fireClose();d.remove(c)}else{c.ownerCt=d;Ext.resumeLayouts(true);return false}}if(a){if(e){e.setActiveTab(a.card)}else{d.setActiveTab(a)}a.focus()}Ext.resumeLayouts(true)},findNextActivatable:function(a){var b=this;if(a.active&&b.items.getCount()>1){return(b.previousTab&&b.previousTab!==a&&!b.previousTab.disabled)?b.previousTab:(a.next("tab[disabled=false]")||a.prev("tab[disabled=false]"))}},setActiveTab:function(a){var b=this;if(!a.disabled&&a!==b.activeTab){if(b.activeTab){if(b.activeTab.isDestroyed){b.previousTab=null}else{b.previousTab=b.activeTab;b.activeTab.deactivate()}}a.activate();b.activeTab=a;b.fireEvent("change",b,a,a.card);b.on({afterlayout:b.afterTabActivate,scope:b,single:true});b.updateLayout()}},afterTabActivate:function(){this.layout.overflowHandler.scrollToItem(this.activeTab)}});Ext.define("Ext.tab.Panel",{extend:"Ext.panel.Panel",alias:"widget.tabpanel",alternateClassName:["Ext.TabPanel"],requires:["Ext.layout.container.Card","Ext.tab.Bar"],tabPosition:"top",removePanelHeader:true,plain:false,itemCls:Ext.baseCSSPrefix+"tabpanel-child",minTabWidth:undefined,maxTabWidth:undefined,deferredRender:true,initComponent:function(){var c=this,b=[].concat(c.dockedItems||[]),a=c.activeTab||(c.activeTab=0);c.layout=new Ext.layout.container.Card(Ext.apply({owner:c,deferredRender:c.deferredRender,itemCls:c.itemCls,activeItem:c.activeTab},c.layout));c.tabBar=new Ext.tab.Bar(Ext.apply({dock:c.tabPosition,plain:c.plain,border:c.border,cardLayout:c.layout,tabPanel:c},c.tabBar));b.push(c.tabBar);c.dockedItems=b;c.addEvents("beforetabchange","tabchange");c.callParent(arguments);c.activeTab=c.getComponent(a);if(c.activeTab){c.activeTab.tab.activate(true);c.tabBar.activeTab=c.activeTab.tab}},setActiveTab:function(a){var c=this,b;a=c.getComponent(a);if(a){b=c.getActiveTab();if(b!==a&&c.fireEvent("beforetabchange",c,a,b)===false){return false}if(!a.isComponent){Ext.suspendLayouts();a=c.add(a);Ext.resumeLayouts()}c.activeTab=a;Ext.suspendLayouts();c.layout.setActiveItem(a);a=c.activeTab=c.layout.getActiveItem();if(a&&a!==b){c.tabBar.setActiveTab(a.tab);Ext.resumeLayouts(true);if(b!==a){c.fireEvent("tabchange",c,a,b)}}else{Ext.resumeLayouts(true)}return a}},getActiveTab:function(){var b=this,a=b.getComponent(b.activeTab);if(a&&b.items.indexOf(a)!=-1){b.activeTab=a}else{b.activeTab=null}return b.activeTab},getTabBar:function(){return this.tabBar},onAdd:function(e,c){var d=this,b=e.tabConfig||{},a={xtype:"tab",card:e,disabled:e.disabled,closable:e.closable,hidden:e.hidden&&!e.hiddenByLayout,tooltip:e.tooltip,tabBar:d.tabBar,closeText:e.closeText};b=Ext.applyIf(b,a);e.tab=d.tabBar.insert(c,b);e.on({scope:d,enable:d.onItemEnable,disable:d.onItemDisable,beforeshow:d.onItemBeforeShow,iconchange:d.onItemIconChange,iconclschange:d.onItemIconClsChange,titlechange:d.onItemTitleChange});if(e.isPanel){if(d.removePanelHeader){if(e.rendered){if(e.header){e.header.hide()}}else{e.header=false}}if(e.isPanel&&d.border){e.setBorder(false)}}},onItemEnable:function(a){a.tab.enable()},onItemDisable:function(a){a.tab.disable()},onItemBeforeShow:function(a){if(a!==this.activeTab){this.setActiveTab(a);return false}},onItemIconChange:function(b,a){b.tab.setIcon(a)},onItemIconClsChange:function(b,a){b.tab.setIconCls(a)},onItemTitleChange:function(a,b){a.tab.setText(b)},doRemove:function(d,b){var c=this,a;if(c.destroying||c.items.getCount()==1){c.activeTab=null}else{if((a=c.tabBar.items.indexOf(c.tabBar.findNextActivatable(d.tab)))!==-1){c.setActiveTab(a)}}this.callParent(arguments);delete d.tab.card;delete d.tab},onRemove:function(b,c){var a=this;b.un({scope:a,enable:a.onItemEnable,disable:a.onItemDisable,beforeshow:a.onItemBeforeShow});if(!a.destroying&&b.tab.ownerCt===a.tabBar){a.tabBar.remove(b.tab)}}});Ext.define("Ext.toolbar.Spacer",{extend:"Ext.Component",alias:"widget.tbspacer",alternateClassName:"Ext.Toolbar.Spacer",baseCls:Ext.baseCSSPrefix+"toolbar-spacer",focusable:false});Ext.define("Ext.tree.Column",{extend:"Ext.grid.column.Column",alias:"widget.treecolumn",tdCls:Ext.baseCSSPrefix+"grid-cell-treecolumn",treePrefix:Ext.baseCSSPrefix+"tree-",elbowPrefix:Ext.baseCSSPrefix+"tree-elbow-",expanderCls:Ext.baseCSSPrefix+"tree-expander",imgText:'<img src="{1}" class="{0}" />',checkboxText:'<input type="button" role="checkbox" class="{0}" {1} />',initComponent:function(){var a=this;a.origRenderer=a.renderer||a.defaultRenderer;a.origScope=a.scope||window;a.renderer=a.treeRenderer;a.scope=a;a.callParent()},treeRenderer:function(l,n,c,b,k,e,j){var s=this,r=[],p=Ext.String.format,u=c.getDepth(),q=s.treePrefix,d=s.elbowPrefix,m=s.expanderCls,i=s.imgText,v=s.checkboxText,h=s.origRenderer.apply(s.origScope,arguments),g=Ext.BLANK_IMAGE_URL,o=c.get("href"),t=c.get("hrefTarget"),a=c.get("cls");while(c){if(!c.isRoot()||(c.isRoot()&&j.rootVisible)){if(c.getDepth()===u){r.unshift(p(i,q+"icon "+q+"icon"+(c.get("icon")?"-inline ":(c.isLeaf()?"-leaf ":"-parent "))+(c.get("iconCls")||""),c.get("icon")||g));if(c.get("checked")!==null){r.unshift(p(v,(q+"checkbox")+(c.get("checked")?" "+q+"checkbox-checked":""),c.get("checked")?'aria-checked="true"':""));if(c.get("checked")){n.tdCls+=(" "+q+"checked")}}if(c.isLast()){if(c.isExpandable()){r.unshift(p(i,(d+"end-plus "+m),g))}else{r.unshift(p(i,(d+"end"),g))}}else{if(c.isExpandable()){r.unshift(p(i,(d+"plus "+m),g))}else{r.unshift(p(i,(q+"elbow"),g))}}}else{if(c.isLast()||c.getDepth()===0){r.unshift(p(i,(d+"empty"),g))}else{if(c.getDepth()!==0){r.unshift(p(i,(d+"line"),g))}}}}c=c.parentNode}if(o){r.push('<a href="',o,'" target="',t,'">',h,"</a>")}else{r.push(h)}if(a){n.tdCls+=" "+a}return r.join("")},defaultRenderer:function(a){return a}});Ext.define("Ext.tree.View",{extend:"Ext.view.Table",alias:"widget.treeview",requires:["Ext.data.NodeStore"],loadingCls:Ext.baseCSSPrefix+"grid-tree-loading",expandedCls:Ext.baseCSSPrefix+"grid-tree-node-expanded",leafCls:Ext.baseCSSPrefix+"grid-tree-node-leaf",expanderSelector:"."+Ext.baseCSSPrefix+"tree-expander",checkboxSelector:"."+Ext.baseCSSPrefix+"tree-checkbox",expanderIconOverCls:Ext.baseCSSPrefix+"tree-expander-over",nodeAnimWrapCls:Ext.baseCSSPrefix+"tree-animator-wrap",blockRefresh:true,loadMask:false,rootVisible:true,deferInitialRefresh:false,expandDuration:250,collapseDuration:250,toggleOnDblClick:true,stripeRows:false,uiFields:["expanded","loaded","checked","expandable","leaf","icon","iconCls","loading","qtip","qtitle"],initComponent:function(){var a=this,b=a.panel.getStore();if(a.initialConfig.animate===undefined){a.animate=Ext.enableFx}a.store=new Ext.data.NodeStore({treeStore:b,recursive:true,rootVisible:a.rootVisible,listeners:{beforeexpand:a.onBeforeExpand,expand:a.onExpand,beforecollapse:a.onBeforeCollapse,collapse:a.onCollapse,write:a.onStoreWrite,datachanged:a.onStoreDataChanged,scope:a}});if(a.node){a.setRootNode(a.node)}a.animQueue={};a.animWraps={};a.addEvents("afteritemexpand","afteritemcollapse");a.callParent(arguments);a.on({element:"el",scope:a,delegate:a.expanderSelector,mouseover:a.onExpanderMouseOver,mouseout:a.onExpanderMouseOut});a.on({element:"el",scope:a,delegate:a.checkboxSelector,click:a.onCheckboxChange})},getMaskStore:function(){return this.panel.getStore()},afterComponentLayout:function(){this.callParent(arguments);var a=this.stretcher;if(a){a.setWidth((this.getWidth()-Ext.getScrollbarSize().width))}},processUIEvent:function(a){if(a.getTarget("."+this.nodeAnimWrapCls,this.el)){return false}return this.callParent(arguments)},onClear:function(){this.store.removeAll()},setRootNode:function(b){var a=this;a.store.setNode(b);a.node=b},onCheckboxChange:function(d,a){var c=this,b=d.getTarget(c.getItemSelector(),c.getTargetEl());if(b){c.onCheckChange(c.getRecord(b))}},onCheckChange:function(a){var b=a.get("checked");if(Ext.isBoolean(b)){b=!b;a.set("checked",b);this.fireEvent("checkchange",a,b)}},getChecked:function(){var a=[];this.node.cascadeBy(function(b){if(b.get("checked")){a.push(b)}});return a},isItemChecked:function(a){return a.get("checked")},createAnimWrap:function(j,k){var g="",e=this.panel.headerCt,b=e.getGridColumns(),h=0,l=b.length,m,d=this.getNode(j),a,c;for(;h<l;h++){m=b[h];g+='<th style="width: '+(m.hidden?0:m.getDesiredWidth())+'px; height: 0px;"></th>'}c=Ext.get(d);a=c.insertSibling({tag:"tr",html:['<td colspan="'+e.getColumnCount()+'">','<div class="'+this.nodeAnimWrapCls+'">','<table class="'+Ext.baseCSSPrefix+'grid-table" style="width: '+e.getFullWidth()+'px;"><tbody>',g,"</tbody></table>","</div>","</td>"].join("")},"after");return{record:j,node:d,el:a,expanding:false,collapsing:false,animating:false,animateEl:a.down("div"),targetEl:a.down("tbody")}},getAnimWrap:function(d,a){if(!this.animate){return null}var b=this.animWraps,c=b[d.internalId];if(a!==false){while(!c&&d){d=d.parentNode;if(d){c=b[d.internalId]}}}return c},doAdd:function(b,d,i){var j=this,g=d[0],l=g.parentNode,k=j.all.elements,n=0,e=j.getAnimWrap(l),m,c,h;if(!e||!e.expanding){return j.callParent(arguments)}l=e.record;m=e.targetEl;c=m.dom.childNodes;h=c.length-1;n=i-j.indexOf(l)-1;if(!h||n>=h){m.appendChild(b)}else{Ext.fly(c[n+1]).insertSibling(b,"before",true)}Ext.Array.insert(k,i,b);if(e.isAnimating){j.onExpand(l)}},beginBulkUpdate:function(){this.bulkUpdate=true},endBulkUpdate:function(){this.bulkUpdate=false},onRemove:function(e,a,b){var d=this,c=d.bulkUpdate;if(d.viewReady){d.doRemove(a,b);if(!c){d.updateIndexes(b)}if(d.store.getCount()===0){d.refresh()}if(!c){d.fireEvent("itemremove",a,b)}}},doRemove:function(a,c){var h=this,d=h.all,b=h.getAnimWrap(a),g=d.item(c),e=g?g.dom:null;if(!e||!b||!b.collapsing){return h.callParent(arguments)}b.targetEl.appendChild(e);d.removeElement(c)},onBeforeExpand:function(d,b,c){var e=this,a;if(!e.rendered||!e.animate){return}if(e.getNode(d)){a=e.getAnimWrap(d,false);if(!a){a=e.animWraps[d.internalId]=e.createAnimWrap(d);a.animateEl.setHeight(0)}else{if(a.collapsing){a.targetEl.select(e.itemSelector).remove()}}a.expanding=true;a.collapsing=false}},onExpand:function(i){var h=this,e=h.animQueue,a=i.getId(),c=h.getNode(i),g=c?h.indexOf(c):-1,d,b,j;if(h.singleExpand){h.ensureSingleExpand(i)}if(g===-1){return}d=h.getAnimWrap(i,false);if(!d){h.isExpandingOrCollapsing=false;h.fireEvent("afteritemexpand",i,g,c);return}b=d.animateEl;j=d.targetEl;b.stopAnimation();e[a]=true;b.slideIn("t",{duration:h.expandDuration,listeners:{scope:h,lastframe:function(){d.el.insertSibling(j.query(h.itemSelector),"before");d.el.remove();h.refreshSize();delete h.animWraps[d.record.internalId];delete e[a]}},callback:function(){h.isExpandingOrCollapsing=false;h.fireEvent("afteritemexpand",i,g,c)}});d.isAnimating=true},onBeforeCollapse:function(d,b,c){var e=this,a;if(!e.rendered||!e.animate){return}if(e.getNode(d)){a=e.getAnimWrap(d);if(!a){a=e.animWraps[d.internalId]=e.createAnimWrap(d,c)}else{if(a.expanding){a.targetEl.select(this.itemSelector).remove()}}a.expanding=false;a.collapsing=true}},onCollapse:function(i){var h=this,e=h.animQueue,a=i.getId(),c=h.getNode(i),g=c?h.indexOf(c):-1,d=h.getAnimWrap(i),b,j;if(g===-1){return}if(!d){h.isExpandingOrCollapsing=false;h.fireEvent("afteritemcollapse",i,g,c);return}b=d.animateEl;j=d.targetEl;e[a]=true;b.stopAnimation();b.slideOut("t",{duration:h.collapseDuration,listeners:{scope:h,lastframe:function(){d.el.remove();h.refreshSize();delete h.animWraps[d.record.internalId];delete e[a]}},callback:function(){h.isExpandingOrCollapsing=false;h.fireEvent("afteritemcollapse",i,g,c)}});d.isAnimating=true},isAnimating:function(a){return !!this.animQueue[a.getId()]},collectData:function(c){var g=this.callParent(arguments),e=g.rows,a=e.length,d=0,h,b;for(;d<a;d++){h=e[d];b=c[d];if(b.get("qtip")){h.rowAttr='data-qtip="'+b.get("qtip")+'"';if(b.get("qtitle")){h.rowAttr+=' data-qtitle="'+b.get("qtitle")+'"'}}if(b.isExpanded()){h.rowCls=(h.rowCls||"")+" "+this.expandedCls}if(b.isLeaf()){h.rowCls=(h.rowCls||"")+" "+this.leafCls}if(b.isLoading()){h.rowCls=(h.rowCls||"")+" "+this.loadingCls}}return g},expand:function(b,a,d,c){return b.expand(a,d,c)},collapse:function(b,a,d,c){return b.collapse(a,d,c)},toggle:function(c,b,g,d){var e=this,a=!!this.animate;if(!a||!this.isExpandingOrCollapsing){if(!c.isLeaf()){this.isExpandingOrCollapsing=a}if(c.isExpanded()){e.collapse(c,b,g,d)}else{e.expand(c,b,g,d)}}},onItemDblClick:function(a,e,c){var d=this,b=d.editingPlugin;d.callParent(arguments);if(d.toggleOnDblClick&&a.isExpandable()&&!(b&&b.clicksToEdit===2)){d.toggle(a)}},onBeforeItemMouseDown:function(a,c,b,d){if(d.getTarget(this.expanderSelector,c)){return false}return this.callParent(arguments)},onItemClick:function(a,c,b,d){if(d.getTarget(this.expanderSelector,c)&&a.isExpandable()){this.toggle(a,d.ctrlKey);return false}return this.callParent(arguments)},onExpanderMouseOver:function(b,a){b.getTarget(this.cellSelector,10,true).addCls(this.expanderIconOverCls)},onExpanderMouseOut:function(b,a){b.getTarget(this.cellSelector,10,true).removeCls(this.expanderIconOverCls)},getTreeStore:function(){return this.panel.store},ensureSingleExpand:function(b){var a=b.parentNode;if(a){a.eachChild(function(c){if(c!==b&&c.isExpanded()){c.collapse()}})}},shouldUpdateCell:function(d,c){if(c){var b=0,a=c.length;for(;b<a;++b){if(Ext.Array.contains(this.uiFields,c[b])){return true}}}return this.callParent(arguments)},onStoreWrite:function(b,a){var c=this.panel.store;c.fireEvent("write",c,a)},onStoreDataChanged:function(b,a){var c=this.panel.store;c.fireEvent("datachanged",c)}});Ext.define("Ext.tree.Panel",{extend:"Ext.panel.Table",alias:"widget.treepanel",alternateClassName:["Ext.tree.TreePanel","Ext.TreePanel"],requires:["Ext.tree.View","Ext.selection.TreeModel","Ext.tree.Column","Ext.data.TreeStore"],viewType:"treeview",selType:"treemodel",treeCls:Ext.baseCSSPrefix+"tree-panel",deferRowRender:false,rowLines:false,lines:true,useArrows:false,singleExpand:false,ddConfig:{enableDrag:true,enableDrop:true},rootVisible:true,displayField:"text",root:null,normalCfgCopy:["displayField","root","singleExpand","useArrows","lines","rootVisible","scroll"],lockedCfgCopy:["displayField","root","singleExpand","useArrows","lines","rootVisible"],isTree:true,constructor:function(a){a=a||{};if(a.animate===undefined){a.animate=Ext.isDefined(this.animate)?this.animate:Ext.enableFx}this.enableAnimations=a.animate;delete a.animate;this.callParent([a])},initComponent:function(){var c=this,b=[c.treeCls],a;if(c.useArrows){b.push(Ext.baseCSSPrefix+"tree-arrows");c.lines=false}if(c.lines){b.push(Ext.baseCSSPrefix+"tree-lines")}else{if(!c.useArrows){b.push(Ext.baseCSSPrefix+"tree-no-lines")}}if(Ext.isString(c.store)){c.store=Ext.StoreMgr.lookup(c.store)}else{if(!c.store||Ext.isObject(c.store)&&!c.store.isStore){c.store=new Ext.data.TreeStore(Ext.apply({},c.store||{},{root:c.root,fields:c.fields,model:c.model,folderSort:c.folderSort}))}else{if(c.root){c.store=Ext.data.StoreManager.lookup(c.store);c.store.setRootNode(c.root);if(c.folderSort!==undefined){c.store.folderSort=c.folderSort;c.store.sort()}}}}c.viewConfig=Ext.apply({},c.viewConfig);c.viewConfig=Ext.applyIf(c.viewConfig,{rootVisible:c.rootVisible,animate:c.enableAnimations,singleExpand:c.singleExpand,node:c.store.getRootNode(),hideHeaders:c.hideHeaders});c.mon(c.store,{scope:c,rootchange:c.onRootChange,clear:c.onClear});c.relayEvents(c.store,["beforeload","load"]);c.mon(c.store,{append:c.createRelayer("itemappend"),remove:c.createRelayer("itemremove"),move:c.createRelayer("itemmove",[0,4]),insert:c.createRelayer("iteminsert"),beforeappend:c.createRelayer("beforeitemappend"),beforeremove:c.createRelayer("beforeitemremove"),beforemove:c.createRelayer("beforeitemmove"),beforeinsert:c.createRelayer("beforeiteminsert"),expand:c.createRelayer("itemexpand",[0,1]),collapse:c.createRelayer("itemcollapse",[0,1]),beforeexpand:c.createRelayer("beforeitemexpand",[0,1]),beforecollapse:c.createRelayer("beforeitemcollapse",[0,1])});if(!c.columns){if(c.initialConfig.hideHeaders===undefined){c.hideHeaders=true}c.addCls(Ext.baseCSSPrefix+"autowidth-table");c.columns=[{xtype:"treecolumn",text:"Name",width:Ext.isIE6?null:10000,dataIndex:c.displayField}]}if(c.cls){b.push(c.cls)}c.cls=b.join(" ");c.callParent();a=c.getView();c.relayEvents(a,["checkchange","afteritemexpand","afteritemcollapse"]);if(!a.rootVisible&&!c.getRootNode()){c.setRootNode({expanded:true})}},onClear:function(){this.view.onClear()},setRootNode:function(){return this.store.setRootNode.apply(this.store,arguments)},getRootNode:function(){return this.store.getRootNode()},onRootChange:function(a){this.view.setRootNode(a)},getChecked:function(){return this.getView().getChecked()},isItemChecked:function(a){return a.get("checked")},expandNode:function(b,a,d,c){return this.getView().expand(b,a,d,c||this)},collapseNode:function(b,a,d,c){return this.getView().collapse(b,a,d,c||this)},expandAll:function(g,d){var e=this,b=e.getRootNode(),c=e.enableAnimations,a=e.getView();if(b){if(!c){a.beginBulkUpdate()}b.expand(true,g,d||e);if(!c){a.endBulkUpdate()}}},collapseAll:function(g,d){var e=this,b=e.getRootNode(),c=e.enableAnimations,a=e.getView();if(b){if(!c){a.beginBulkUpdate()}d=d||e;if(a.rootVisible){b.collapse(true,g,d)}else{b.collapseChildren(true,g,d)}if(!c){a.endBulkUpdate()}}},expandPath:function(l,g,a,h,k){var d=this,c=d.getRootNode(),b=1,e=d.getView(),j,i;g=g||d.getRootNode().idProperty;a=a||"/";if(Ext.isEmpty(l)){Ext.callback(h,k||d,[false,null]);return}j=l.split(a);if(c.get(g)!=j[1]){Ext.callback(h,k||d,[false,c]);return}i=function(){if(++b===j.length){Ext.callback(h,k||d,[true,c]);return}var m=c.findChild(g,j[b]);if(!m){Ext.callback(h,k||d,[false,c]);return}c=m;c.expand(false,i)};c.expand(false,i)},selectPath:function(j,d,a,g,i){var b=this,c,h,e;d=d||b.getRootNode().idProperty;a=a||"/";h=j.split(a);e=h.pop();if(h.length>1){b.expandPath(h.join(a),d,a,function(m,l){var k=l;if(m&&l){l=l.findChild(d,e);if(l){b.getSelectionModel().select(l);Ext.callback(g,i||b,[true,l]);return}}Ext.callback(g,i||b,[false,k])},b)}else{c=b.getRootNode();if(c.getId()===e){b.getSelectionModel().select(c);Ext.callback(g,i||b,[true,c])}else{Ext.callback(g,i||b,[false,null])}}}});Ext.define("Ext.view.DragZone",{extend:"Ext.dd.DragZone",containerScroll:false,constructor:function(b){var e=this,a,d,c;Ext.apply(e,b);if(!e.ddGroup){e.ddGroup="view-dd-zone-"+e.view.id}a=e.view;d=a.ownerCt;if(d){c=d.getTargetEl().dom}else{c=a.el.dom.parentNode}e.callParent([c]);e.ddel=Ext.get(document.createElement("div"));e.ddel.addCls(Ext.baseCSSPrefix+"grid-dd-wrap")},init:function(c,a,b){this.initTarget(c,a,b);this.view.mon(this.view,{itemmousedown:this.onItemMouseDown,scope:this})},onValidDrop:function(b,a,c){this.callParent();b.el.focus()},onItemMouseDown:function(b,a,d,c,g){if(!this.isPreventDrag(g,a,d,c)){this.view.focus();this.handleMouseDown(g);if(b.getSelectionModel().selectionMode=="MULTI"&&!g.ctrlKey&&b.getSelectionModel().isSelected(a)){return false}}},isPreventDrag:function(a){return false},getDragData:function(c){var a=this.view,b=c.getTarget(a.getItemSelector());if(b){return{copy:a.copy||(a.allowCopy&&c.ctrlKey),event:new Ext.EventObjectImpl(c),view:a,ddel:this.ddel,item:b,records:a.getSelectionModel().getSelection(),fromPosition:Ext.fly(b).getXY()}}},onInitDrag:function(b,j){var g=this,h=g.dragData,d=h.view,a=d.getSelectionModel(),c=d.getRecord(h.item),i=h.event;if(!a.isSelected(c)){a.select(c,true)}h.records=a.getSelection();g.ddel.update(g.getDragText());g.proxy.update(g.ddel.dom);g.onStartDrag(b,j);return true},getDragText:function(){var a=this.dragData.records.length;return Ext.String.format(this.dragText,a,a==1?"":"s")},getRepairXY:function(b,a){return a?a.fromPosition:false}});Ext.define("Ext.tree.ViewDragZone",{extend:"Ext.view.DragZone",isPreventDrag:function(b,a){return(a.get("allowDrag")===false)||!!b.getTarget(this.view.expanderSelector)},afterRepair:function(){var h=this,a=h.view,i=a.selectedItemCls,b=h.dragData.records,g,e=b.length,c=Ext.fly,d;if(Ext.enableFx&&h.repairHighlight){for(g=0;g<e;g++){d=a.getNode(b[g]);c(d.firstChild).highlight(h.repairHighlightColor,{listeners:{beforeanimate:function(){if(a.isSelected(d)){c(d).removeCls(i)}},afteranimate:function(){if(a.isSelected(d)){c(d).addCls(i)}}}})}}h.dragging=false}});Ext.define("Ext.tree.ViewDropZone",{extend:"Ext.view.DropZone",allowParentInserts:false,allowContainerDrops:false,appendOnly:false,expandDelay:500,indicatorCls:Ext.baseCSSPrefix+"tree-ddindicator",expandNode:function(b){var a=this.view;if(!b.isLeaf()&&!b.isExpanded()){a.expand(b);this.expandProcId=false}},queueExpand:function(a){this.expandProcId=Ext.Function.defer(this.expandNode,this.expandDelay,this,[a])},cancelExpand:function(){if(this.expandProcId){clearTimeout(this.expandProcId);this.expandProcId=false}},getPosition:function(g,b){var j=this.view,c=j.getRecord(b),h=g.getPageY(),k=c.isLeaf(),a=false,i=Ext.fly(b).getRegion(),d;if(c.isRoot()){return"append"}if(this.appendOnly){return k?false:"append"}if(!this.allowParentInsert){a=c.hasChildNodes()&&c.isExpanded()}d=(i.bottom-i.top)/(k?2:3);if(h>=i.top&&h<(i.top+d)){return"before"}else{if(!a&&(k||(h>=(i.bottom-d)&&h<=i.bottom))){return"after"}else{return"append"}}},isValidDropPoint:function(b,j,n,k,g){if(!b||!g.item){return false}var o=this.view,l=o.getRecord(b),d=g.records,a=d.length,m=d.length,c,h;if(!(l&&j&&a)){return false}for(c=0;c<m;c++){h=d[c];if(h.isNode&&h.contains(l)){return false}}if(j==="append"&&l.get("allowDrop")===false){return false}else{if(j!="append"&&l.parentNode.get("allowDrop")===false){return false}}if(Ext.Array.contains(d,l)){return false}return true},onNodeOver:function(a,i,g,c){var d=this.getPosition(g,a),b=this.dropNotAllowed,j=this.view,h=j.getRecord(a),k=this.getIndicator(),m=0,l=0;this.cancelExpand();if(d=="append"&&!this.expandProcId&&!Ext.Array.contains(c.records,h)&&!h.isLeaf()&&!h.isExpanded()){this.queueExpand(h)}if(this.isValidDropPoint(a,d,i,g,c)){this.valid=true;this.currentPosition=d;this.overRecord=h;k.setWidth(Ext.fly(a).getWidth());l=Ext.fly(a).getY()-Ext.fly(j.el).getY()-1;if(d=="before"){b=h.isFirst()?Ext.baseCSSPrefix+"tree-drop-ok-above":Ext.baseCSSPrefix+"tree-drop-ok-between";k.showAt(0,l);i.proxy.show()}else{if(d=="after"){b=h.isLast()?Ext.baseCSSPrefix+"tree-drop-ok-below":Ext.baseCSSPrefix+"tree-drop-ok-between";l+=Ext.fly(a).getHeight();k.showAt(0,l);i.proxy.show()}else{b=Ext.baseCSSPrefix+"tree-drop-ok-append";k.hide()}}}else{this.valid=false}this.currentCls=b;return b},onContainerOver:function(a,c,b){return c.getTarget("."+this.indicatorCls)?this.currentCls:this.dropNotAllowed},notifyOut:function(){this.callParent(arguments);this.cancelExpand()},handleNodeDrop:function(d,l,e){var n=this,o=n.view,g=l.parentNode,p=o.getStore(),r=[],a,c,k,b,j,m,q,h;if(d.copy){a=d.records;d.records=[];for(c=0,k=a.length;c<k;c++){d.records.push(Ext.apply({},a[c].data))}}n.cancelExpand();if(e=="before"){b=g.insertBefore;j=[null,l];l=g}else{if(e=="after"){if(l.nextSibling){b=g.insertBefore;j=[null,l.nextSibling]}else{b=g.appendChild;j=[null]}l=g}else{if(!l.isExpanded()){m=true}b=l.appendChild;j=[null]}}q=function(){var u,t,s,i,v;for(c=0,k=d.records.length;c<k;c++){j[0]=d.records[c];u=b.apply(l,j);if(Ext.enableFx&&n.dropHighlight){r.push(o.getNode(u))}}if(Ext.enableFx&&n.dropHighlight){s=r.length;i=n.dropHighlightColor;for(t=0;t<s;t++){v=r[t];if(v){Ext.fly(v.firstChild?v.firstChild:v).highlight(i)}}}};if(m){l.expand(false,q)}else{q()}}});Ext.define("Ext.tree.plugin.TreeViewDragDrop",{extend:"Ext.AbstractPlugin",alias:"plugin.treeviewdragdrop",uses:["Ext.tree.ViewDragZone","Ext.tree.ViewDropZone"],dragText:"{0} selected node{1}",allowParentInserts:false,allowContainerDrops:false,appendOnly:false,ddGroup:"TreeDD",expandDelay:1000,enableDrop:true,enableDrag:true,nodeHighlightColor:"c3daf9",nodeHighlightOnDrop:Ext.enableFx,nodeHighlightOnRepair:Ext.enableFx,init:function(a){a.on("render",this.onViewRender,this,{single:true})},destroy:function(){Ext.destroy(this.dragZone,this.dropZone)},onViewRender:function(a){var b=this;if(b.enableDrag){b.dragZone=new Ext.tree.ViewDragZone({view:a,ddGroup:b.dragGroup||b.ddGroup,dragText:b.dragText,repairHighlightColor:b.nodeHighlightColor,repairHighlight:b.nodeHighlightOnRepair})}if(b.enableDrop){b.dropZone=new Ext.tree.ViewDropZone({view:a,ddGroup:b.dropGroup||b.ddGroup,allowContainerDrops:b.allowContainerDrops,appendOnly:b.appendOnly,allowParentInserts:b.allowParentInserts,expandDelay:b.expandDelay,dropHighlightColor:b.nodeHighlightColor,dropHighlight:b.nodeHighlightOnDrop})}}});Ext.define("Ext.util.CSS",(function(){var d=null,c=document,b=/(-[a-z])/gi,a=function(e,g){return g.charAt(1).toUpperCase()};return{singleton:true,constructor:function(){this.rules={};this.initialized=false},createStyleSheet:function(i,l){var h,g=c.getElementsByTagName("head")[0],k=c.createElement("style");k.setAttribute("type","text/css");if(l){k.setAttribute("id",l)}if(Ext.isIE){g.appendChild(k);h=k.styleSheet;h.cssText=i}else{try{k.appendChild(c.createTextNode(i))}catch(j){k.cssText=i}g.appendChild(k);h=k.styleSheet?k.styleSheet:(k.sheet||c.styleSheets[c.styleSheets.length-1])}this.cacheStyleSheet(h);return h},removeStyleSheet:function(g){var e=document.getElementById(g);if(e){e.parentNode.removeChild(e)}},swapStyleSheet:function(i,e){var h=document,g;this.removeStyleSheet(i);g=h.createElement("link");g.setAttribute("rel","stylesheet");g.setAttribute("type","text/css");g.setAttribute("id",i);g.setAttribute("href",e);h.getElementsByTagName("head")[0].appendChild(g)},refreshCache:function(){return this.getRules(true)},cacheStyleSheet:function(l){if(!d){d={}}try{var o=l.cssRules||l.rules,m,k=o.length-1,g,h;for(;k>=0;--k){m=o[k].selectorText;if(m){m=m.split(",");h=m.length;for(g=0;g<h;g++){d[Ext.String.trim(m[g]).toLowerCase()]=o[k]}}}}catch(n){}},getRules:function(h){if(d===null||h){d={};var k=c.styleSheets,j=0,g=k.length;for(;j<g;j++){try{if(!k[j].disabled){this.cacheStyleSheet(k[j])}}catch(l){}}}return d},getRule:function(e,h){var g=this.getRules(h),j;if(!Ext.isArray(e)){return g[e.toLowerCase()]}for(j=0;j<e.length;j++){if(g[e[j]]){return g[e[j].toLowerCase()]}}return null},updateRule:function(e,j,h){var k,g;if(!Ext.isArray(e)){k=this.getRule(e);if(k){k.style[j.replace(b,a)]=h;return true}}else{for(g=0;g<e.length;g++){if(this.updateRule(e[g],j,h)){return true}}}return false}}}()));Ext.define("Ext.util.Cookies",{singleton:true,set:function(c,e){var a=arguments,i=arguments.length,b=(i>2)?a[2]:null,h=(i>3)?a[3]:"/",d=(i>4)?a[4]:null,g=(i>5)?a[5]:false;document.cookie=c+"="+escape(e)+((b===null)?"":("; expires="+b.toGMTString()))+((h===null)?"":("; path="+h))+((d===null)?"":("; domain="+d))+((g===true)?"; secure":"")},get:function(d){var b=d+"=",g=b.length,a=document.cookie.length,e=0,c=0;while(e<a){c=e+g;if(document.cookie.substring(e,c)==b){return this.getCookieVal(c)}e=document.cookie.indexOf(" ",e)+1;if(e===0){break}}return null},clear:function(a,b){if(this.get(a)){b=b||"/";document.cookie=a+"=; expires=Thu, 01-Jan-70 00:00:01 GMT; path="+b}},getCookieVal:function(b){var a=document.cookie.indexOf(";",b);if(a==-1){a=document.cookie.length}return unescape(document.cookie.substring(b,a))}});Ext.define("Ext.util.Grouper",{extend:"Ext.util.Sorter",isGrouper:true,getGroupString:function(a){return a.get(this.property)}});Ext.define("Ext.util.History",{singleton:true,alternateClassName:"Ext.History",mixins:{observable:"Ext.util.Observable"},useTopWindow:true,fieldId:Ext.baseCSSPrefix+"history-field",iframeId:Ext.baseCSSPrefix+"history-frame",constructor:function(){var a=this;a.oldIEMode=Ext.isIE6||Ext.isIE7||!Ext.isStrict&&Ext.isIE8;a.iframe=null;a.hiddenField=null;a.ready=false;a.currentToken=null;a.mixins.observable.constructor.call(a)},getHash:function(){var a=window.location.href,b=a.indexOf("#");return b>=0?a.substr(b+1):null},setHash:function(d){var a=this,c=a.useTopWindow?window.top:window;try{c.location.hash=d}catch(b){}},doSave:function(){this.hiddenField.value=this.currentToken},handleStateChange:function(a){this.currentToken=a;this.fireEvent("change",a)},updateIFrame:function(b){var a='<html><body><div id="state">'+Ext.util.Format.htmlEncode(b)+"</div></body></html>",d;try{d=this.iframe.contentWindow.document;d.open();d.write(a);d.close();return true}catch(c){return false}},checkIFrame:function(){var d=this,b=d.iframe.contentWindow,e,c,a,g;if(!b||!b.document){Ext.Function.defer(this.checkIFrame,10,this);return}e=b.document;c=e.getElementById("state");a=c?c.innerText:null;g=d.getHash();Ext.TaskManager.start({run:function(){var k=b.document,j=k.getElementById("state"),h=j?j.innerText:null,i=d.getHash();if(h!==a){a=h;d.handleStateChange(h);d.setHash(h);g=h;d.doSave()}else{if(i!==g){g=i;d.updateIFrame(i)}}},interval:50,scope:d});d.ready=true;d.fireEvent("ready",d)},startUp:function(){var a=this,b;a.currentToken=a.hiddenField.value||this.getHash();if(a.oldIEMode){a.checkIFrame()}else{b=a.getHash();Ext.TaskManager.start({run:function(){var c=a.getHash();if(c!==b){b=c;a.handleStateChange(b);a.doSave()}},interval:50,scope:a});a.ready=true;a.fireEvent("ready",a)}},init:function(d,b){var c=this,a=Ext.DomHelper;if(c.ready){Ext.callback(d,b,[c]);return}if(!Ext.isReady){Ext.onReady(function(){c.init(d,b)});return}c.hiddenField=Ext.getDom(c.fieldId);if(!c.hiddenField){c.hiddenField=Ext.getBody().createChild({id:Ext.id(),tag:"form",cls:Ext.baseCSSPrefix+"hide-display",children:[{tag:"input",type:"hidden",id:c.fieldId}]},false,true).firstChild}if(c.oldIEMode){c.iframe=Ext.getDom(c.iframeId);if(!c.iframe){c.iframe=a.append(c.hiddenField.parentNode,{tag:"iframe",id:c.iframeId,src:Ext.SSL_SECURE_URL})}}c.addEvents("ready","change");if(d){c.on("ready",d,b,{single:true})}c.startUp()},add:function(a,c){var b=this;if(c!==false){if(b.getToken()===a){return true}}if(b.oldIEMode){return b.updateIFrame(a)}else{b.setHash(a);return true}},back:function(){window.history.go(-1)},forward:function(){window.history.go(1)},getToken:function(){return this.ready?this.currentToken:this.getHash()}});Ext.define("Ext.util.Point",{extend:"Ext.util.Region",statics:{fromEvent:function(a){a=(a.changedTouches&&a.changedTouches.length>0)?a.changedTouches[0]:a;return new this(a.pageX,a.pageY)}},constructor:function(a,b){this.callParent([b,a,b,a])},toString:function(){return"Point["+this.x+","+this.y+"]"},equals:function(a){return(this.x==a.x&&this.y==a.y)},isWithin:function(b,a){if(!Ext.isObject(a)){a={x:a,y:a}}return(this.x<=b.x+a.x&&this.x>=b.x-a.x&&this.y<=b.y+a.y&&this.y>=b.y-a.y)},roundedEquals:function(a){return(Math.round(this.x)==Math.round(a.x)&&Math.round(this.y)==Math.round(a.y))}},function(){this.prototype.translate=Ext.util.Region.prototype.translateBy});Ext.define("Ext.view.TableChunker",{singleton:true,requires:["Ext.XTemplate"],metaTableTpl:["{%if (this.openTableWrap)out.push(this.openTableWrap())%}",'<table class="'+Ext.baseCSSPrefix+"grid-table "+Ext.baseCSSPrefix+'grid-table-resizer" border="0" cellspacing="0" cellpadding="0" {[this.embedFullWidth(values)]}>',"<tbody>",'<tr class="'+Ext.baseCSSPrefix+'grid-header-row">','<tpl for="columns">','<th class="'+Ext.baseCSSPrefix+'grid-col-resizer-{id}" style="width: {width}px; height: 0px;"></th>',"</tpl>","</tr>","{[this.openRows()]}","{row}",'<tpl for="features">',"{[this.embedFeature(values, parent, xindex, xcount)]}","</tpl>","{[this.closeRows()]}","</tbody>","</table>","{%if (this.closeTableWrap)out.push(this.closeTableWrap())%}"],constructor:function(){Ext.XTemplate.prototype.recurse=function(b,a){return this.apply(a?b[a]:b)}},embedFeature:function(b,d,a,e){var c="";if(!b.disabled){c=b.getFeatureTpl(b,d,a,e)}return c},embedFullWidth:function(b){var a='style="width:{fullWidth}px;';if(!b.rowCount){a+="height:1px;"}return a+'"'},openRows:function(){return'<tpl for="rows">'},closeRows:function(){return"</tpl>"},metaRowTpl:['<tr class="'+Ext.baseCSSPrefix+'grid-row {[this.embedRowCls()]}" {[this.embedRowAttr()]}>','<tpl for="columns">','<td class="{cls} '+Ext.baseCSSPrefix+"grid-cell "+Ext.baseCSSPrefix+'grid-cell-{columnId} {{id}-modified} {{id}-tdCls} {[this.firstOrLastCls(xindex, xcount)]}" {{id}-tdAttr}>','<div {unselectableAttr} class="'+Ext.baseCSSPrefix+'grid-cell-inner {unselectableCls}" style="text-align: {align}; {{id}-style};">{{id}}</div>',"</td>","</tpl>","</tr>"],firstOrLastCls:function(a,b){if(a===1){return Ext.view.Table.prototype.firstCls}else{if(a===b){return Ext.view.Table.prototype.lastCls}}},embedRowCls:function(){return"{rowCls}"},embedRowAttr:function(){return"{rowAttr}"},openTableWrap:undefined,closeTableWrap:undefined,getTableTpl:function(k,b){var j,h={openRows:this.openRows,closeRows:this.closeRows,embedFeature:this.embedFeature,embedFullWidth:this.embedFullWidth,openTableWrap:this.openTableWrap,closeTableWrap:this.closeTableWrap},g={},c=k.features||[],m=c.length,e=0,l={embedRowCls:this.embedRowCls,embedRowAttr:this.embedRowAttr,firstOrLastCls:this.firstOrLastCls,unselectableAttr:k.enableTextSelection?"":'unselectable="on"',unselectableCls:k.enableTextSelection?"":Ext.baseCSSPrefix+"unselectable"},d=Array.prototype.slice.call(this.metaRowTpl,0),a;for(;e<m;e++){if(!c[e].disabled){c[e].mutateMetaRowTpl(d);Ext.apply(l,c[e].getMetaRowTplFragments());Ext.apply(g,c[e].getFragmentTpl());Ext.apply(h,c[e].getTableFragments())}}d=new Ext.XTemplate(d.join(""),l);k.row=d.applyTemplate(k);a=new Ext.XTemplate(this.metaTableTpl.join(""),h);j=a.applyTemplate(k);if(!b){j=new Ext.XTemplate(j,g)}return j}});Ext._endTime=new Date().getTime();if(Ext._beforereadyhandler){Ext._beforereadyhandler()};
\ No newline at end of file
diff --git a/test/jquery-1.8.2.js b/test/jquery-1.8.2.js
new file mode 100644
index 0000000..12c7797
--- /dev/null
+++ b/test/jquery-1.8.2.js
@@ -0,0 +1,9440 @@
+/*!
+ * jQuery JavaScript Library v1.8.2
+ * http://jquery.com/
+ *
+ * Includes Sizzle.js
+ * http://sizzlejs.com/
+ *
+ * Copyright 2012 jQuery Foundation and other contributors
+ * Released under the MIT license
+ * http://jquery.org/license
+ *
+ * Date: Thu Sep 20 2012 21:13:05 GMT-0400 (Eastern Daylight Time)
+ */
+(function( window, undefined ) {
+var
+	// A central reference to the root jQuery(document)
+	rootjQuery,
+
+	// The deferred used on DOM ready
+	readyList,
+
+	// Use the correct document accordingly with window argument (sandbox)
+	document = window.document,
+	location = window.location,
+	navigator = window.navigator,
+
+	// Map over jQuery in case of overwrite
+	_jQuery = window.jQuery,
+
+	// Map over the $ in case of overwrite
+	_$ = window.$,
+
+	// Save a reference to some core methods
+	core_push = Array.prototype.push,
+	core_slice = Array.prototype.slice,
+	core_indexOf = Array.prototype.indexOf,
+	core_toString = Object.prototype.toString,
+	core_hasOwn = Object.prototype.hasOwnProperty,
+	core_trim = String.prototype.trim,
+
+	// Define a local copy of jQuery
+	jQuery = function( selector, context ) {
+		// The jQuery object is actually just the init constructor 'enhanced'
+		return new jQuery.fn.init( selector, context, rootjQuery );
+	},
+
+	// Used for matching numbers
+	core_pnum = /[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source,
+
+	// Used for detecting and trimming whitespace
+	core_rnotwhite = /\S/,
+	core_rspace = /\s+/,
+
+	// Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)
+	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
+
+	// A simple way to check for HTML strings
+	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
+	rquickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,
+
+	// Match a standalone tag
+	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,
+
+	// JSON RegExp
+	rvalidchars = /^[\],:{}\s]*$/,
+	rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
+	rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,
+	rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d\d*\.|)\d+(?:[eE][\-+]?\d+|)/g,
+
+	// Matches dashed string for camelizing
+	rmsPrefix = /^-ms-/,
+	rdashAlpha = /-([\da-z])/gi,
+
+	// Used by jQuery.camelCase as callback to replace()
+	fcamelCase = function( all, letter ) {
+		return ( letter + "" ).toUpperCase();
+	},
+
+	// The ready event handler and self cleanup method
+	DOMContentLoaded = function() {
+		if ( document.addEventListener ) {
+			document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
+			jQuery.ready();
+		} else if ( document.readyState === "complete" ) {
+			// we're here because readyState === "complete" in oldIE
+			// which is good enough for us to call the dom ready!
+			document.detachEvent( "onreadystatechange", DOMContentLoaded );
+			jQuery.ready();
+		}
+	},
+
+	// [[Class]] -> type pairs
+	class2type = {};
+
+jQuery.fn = jQuery.prototype = {
+	constructor: jQuery,
+	init: function( selector, context, rootjQuery ) {
+		var match, elem, ret, doc;
+
+		// Handle $(""), $(null), $(undefined), $(false)
+		if ( !selector ) {
+			return this;
+		}
+
+		// Handle $(DOMElement)
+		if ( selector.nodeType ) {
+			this.context = this[0] = selector;
+			this.length = 1;
+			return this;
+		}
+
+		// Handle HTML strings
+		if ( typeof selector === "string" ) {
+			if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
+				// Assume that strings that start and end with <> are HTML and skip the regex check
+				match = [ null, selector, null ];
+
+			} else {
+				match = rquickExpr.exec( selector );
+			}
+
+			// Match html or make sure no context is specified for #id
+			if ( match && (match[1] || !context) ) {
+
+				// HANDLE: $(html) -> $(array)
+				if ( match[1] ) {
+					context = context instanceof jQuery ? context[0] : context;
+					doc = ( context && context.nodeType ? context.ownerDocument || context : document );
+
+					// scripts is true for back-compat
+					selector = jQuery.parseHTML( match[1], doc, true );
+					if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
+						this.attr.call( selector, context, true );
+					}
+
+					return jQuery.merge( this, selector );
+
+				// HANDLE: $(#id)
+				} else {
+					elem = document.getElementById( match[2] );
+
+					// Check parentNode to catch when Blackberry 4.6 returns
+					// nodes that are no longer in the document #6963
+					if ( elem && elem.parentNode ) {
+						// Handle the case where IE and Opera return items
+						// by name instead of ID
+						if ( elem.id !== match[2] ) {
+							return rootjQuery.find( selector );
+						}
+
+						// Otherwise, we inject the element directly into the jQuery object
+						this.length = 1;
+						this[0] = elem;
+					}
+
+					this.context = document;
+					this.selector = selector;
+					return this;
+				}
+
+			// HANDLE: $(expr, $(...))
+			} else if ( !context || context.jquery ) {
+				return ( context || rootjQuery ).find( selector );
+
+			// HANDLE: $(expr, context)
+			// (which is just equivalent to: $(context).find(expr)
+			} else {
+				return this.constructor( context ).find( selector );
+			}
+
+		// HANDLE: $(function)
+		// Shortcut for document ready
+		} else if ( jQuery.isFunction( selector ) ) {
+			return rootjQuery.ready( selector );
+		}
+
+		if ( selector.selector !== undefined ) {
+			this.selector = selector.selector;
+			this.context = selector.context;
+		}
+
+		return jQuery.makeArray( selector, this );
+	},
+
+	// Start with an empty selector
+	selector: "",
+
+	// The current version of jQuery being used
+	jquery: "1.8.2",
+
+	// The default length of a jQuery object is 0
+	length: 0,
+
+	// The number of elements contained in the matched element set
+	size: function() {
+		return this.length;
+	},
+
+	toArray: function() {
+		return core_slice.call( this );
+	},
+
+	// Get the Nth element in the matched element set OR
+	// Get the whole matched element set as a clean array
+	get: function( num ) {
+		return num == null ?
+
+			// Return a 'clean' array
+			this.toArray() :
+
+			// Return just the object
+			( num < 0 ? this[ this.length + num ] : this[ num ] );
+	},
+
+	// Take an array of elements and push it onto the stack
+	// (returning the new matched element set)
+	pushStack: function( elems, name, selector ) {
+
+		// Build a new jQuery matched element set
+		var ret = jQuery.merge( this.constructor(), elems );
+
+		// Add the old object onto the stack (as a reference)
+		ret.prevObject = this;
+
+		ret.context = this.context;
+
+		if ( name === "find" ) {
+			ret.selector = this.selector + ( this.selector ? " " : "" ) + selector;
+		} else if ( name ) {
+			ret.selector = this.selector + "." + name + "(" + selector + ")";
+		}
+
+		// Return the newly-formed element set
+		return ret;
+	},
+
+	// Execute a callback for every element in the matched set.
+	// (You can seed the arguments with an array of args, but this is
+	// only used internally.)
+	each: function( callback, args ) {
+		return jQuery.each( this, callback, args );
+	},
+
+	ready: function( fn ) {
+		// Add the callback
+		jQuery.ready.promise().done( fn );
+
+		return this;
+	},
+
+	eq: function( i ) {
+		i = +i;
+		return i === -1 ?
+			this.slice( i ) :
+			this.slice( i, i + 1 );
+	},
+
+	first: function() {
+		return this.eq( 0 );
+	},
+
+	last: function() {
+		return this.eq( -1 );
+	},
+
+	slice: function() {
+		return this.pushStack( core_slice.apply( this, arguments ),
+			"slice", core_slice.call(arguments).join(",") );
+	},
+
+	map: function( callback ) {
+		return this.pushStack( jQuery.map(this, function( elem, i ) {
+			return callback.call( elem, i, elem );
+		}));
+	},
+
+	end: function() {
+		return this.prevObject || this.constructor(null);
+	},
+
+	// For internal use only.
+	// Behaves like an Array's method, not like a jQuery method.
+	push: core_push,
+	sort: [].sort,
+	splice: [].splice
+};
+
+// Give the init function the jQuery prototype for later instantiation
+jQuery.fn.init.prototype = jQuery.fn;
+
+jQuery.extend = jQuery.fn.extend = function() {
+	var options, name, src, copy, copyIsArray, clone,
+		target = arguments[0] || {},
+		i = 1,
+		length = arguments.length,
+		deep = false;
+
+	// Handle a deep copy situation
+	if ( typeof target === "boolean" ) {
+		deep = target;
+		target = arguments[1] || {};
+		// skip the boolean and the target
+		i = 2;
+	}
+
+	// Handle case when target is a string or something (possible in deep copy)
+	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
+		target = {};
+	}
+
+	// extend jQuery itself if only one argument is passed
+	if ( length === i ) {
+		target = this;
+		--i;
+	}
+
+	for ( ; i < length; i++ ) {
+		// Only deal with non-null/undefined values
+		if ( (options = arguments[ i ]) != null ) {
+			// Extend the base object
+			for ( name in options ) {
+				src = target[ name ];
+				copy = options[ name ];
+
+				// Prevent never-ending loop
+				if ( target === copy ) {
+					continue;
+				}
+
+				// Recurse if we're merging plain objects or arrays
+				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
+					if ( copyIsArray ) {
+						copyIsArray = false;
+						clone = src && jQuery.isArray(src) ? src : [];
+
+					} else {
+						clone = src && jQuery.isPlainObject(src) ? src : {};
+					}
+
+					// Never move original objects, clone them
+					target[ name ] = jQuery.extend( deep, clone, copy );
+
+				// Don't bring in undefined values
+				} else if ( copy !== undefined ) {
+					target[ name ] = copy;
+				}
+			}
+		}
+	}
+
+	// Return the modified object
+	return target;
+};
+
+jQuery.extend({
+	noConflict: function( deep ) {
+		if ( window.$ === jQuery ) {
+			window.$ = _$;
+		}
+
+		if ( deep && window.jQuery === jQuery ) {
+			window.jQuery = _jQuery;
+		}
+
+		return jQuery;
+	},
+
+	// Is the DOM ready to be used? Set to true once it occurs.
+	isReady: false,
+
+	// A counter to track how many items to wait for before
+	// the ready event fires. See #6781
+	readyWait: 1,
+
+	// Hold (or release) the ready event
+	holdReady: function( hold ) {
+		if ( hold ) {
+			jQuery.readyWait++;
+		} else {
+			jQuery.ready( true );
+		}
+	},
+
+	// Handle when the DOM is ready
+	ready: function( wait ) {
+
+		// Abort if there are pending holds or we're already ready
+		if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
+			return;
+		}
+
+		// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
+		if ( !document.body ) {
+			return setTimeout( jQuery.ready, 1 );
+		}
+
+		// Remember that the DOM is ready
+		jQuery.isReady = true;
+
+		// If a normal DOM Ready event fired, decrement, and wait if need be
+		if ( wait !== true && --jQuery.readyWait > 0 ) {
+			return;
+		}
+
+		// If there are functions bound, to execute
+		readyList.resolveWith( document, [ jQuery ] );
+
+		// Trigger any bound ready events
+		if ( jQuery.fn.trigger ) {
+			jQuery( document ).trigger("ready").off("ready");
+		}
+	},
+
+	// See test/unit/core.js for details concerning isFunction.
+	// Since version 1.3, DOM methods and functions like alert
+	// aren't supported. They return false on IE (#2968).
+	isFunction: function( obj ) {
+		return jQuery.type(obj) === "function";
+	},
+
+	isArray: Array.isArray || function( obj ) {
+		return jQuery.type(obj) === "array";
+	},
+
+	isWindow: function( obj ) {
+		return obj != null && obj == obj.window;
+	},
+
+	isNumeric: function( obj ) {
+		return !isNaN( parseFloat(obj) ) && isFinite( obj );
+	},
+
+	type: function( obj ) {
+		return obj == null ?
+			String( obj ) :
+			class2type[ core_toString.call(obj) ] || "object";
+	},
+
+	isPlainObject: function( obj ) {
+		// Must be an Object.
+		// Because of IE, we also have to check the presence of the constructor property.
+		// Make sure that DOM nodes and window objects don't pass through, as well
+		if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
+			return false;
+		}
+
+		try {
+			// Not own constructor property must be Object
+			if ( obj.constructor &&
+				!core_hasOwn.call(obj, "constructor") &&
+				!core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
+				return false;
+			}
+		} catch ( e ) {
+			// IE8,9 Will throw exceptions on certain host objects #9897
+			return false;
+		}
+
+		// Own properties are enumerated firstly, so to speed up,
+		// if last one is own, then all properties are own.
+
+		var key;
+		for ( key in obj ) {}
+
+		return key === undefined || core_hasOwn.call( obj, key );
+	},
+
+	isEmptyObject: function( obj ) {
+		var name;
+		for ( name in obj ) {
+			return false;
+		}
+		return true;
+	},
+
+	error: function( msg ) {
+		throw new Error( msg );
+	},
+
+	// data: string of html
+	// context (optional): If specified, the fragment will be created in this context, defaults to document
+	// scripts (optional): If true, will include scripts passed in the html string
+	parseHTML: function( data, context, scripts ) {
+		var parsed;
+		if ( !data || typeof data !== "string" ) {
+			return null;
+		}
+		if ( typeof context === "boolean" ) {
+			scripts = context;
+			context = 0;
+		}
+		context = context || document;
+
+		// Single tag
+		if ( (parsed = rsingleTag.exec( data )) ) {
+			return [ context.createElement( parsed[1] ) ];
+		}
+
+		parsed = jQuery.buildFragment( [ data ], context, scripts ? null : [] );
+		return jQuery.merge( [],
+			(parsed.cacheable ? jQuery.clone( parsed.fragment ) : parsed.fragment).childNodes );
+	},
+
+	parseJSON: function( data ) {
+		if ( !data || typeof data !== "string") {
+			return null;
+		}
+
+		// Make sure leading/trailing whitespace is removed (IE can't handle it)
+		data = jQuery.trim( data );
+
+		// Attempt to parse using the native JSON parser first
+		if ( window.JSON && window.JSON.parse ) {
+			return window.JSON.parse( data );
+		}
+
+		// Make sure the incoming data is actual JSON
+		// Logic borrowed from http://json.org/json2.js
+		if ( rvalidchars.test( data.replace( rvalidescape, "@" )
+			.replace( rvalidtokens, "]" )
+			.replace( rvalidbraces, "")) ) {
+
+			return ( new Function( "return " + data ) )();
+
+		}
+		jQuery.error( "Invalid JSON: " + data );
+	},
+
+	// Cross-browser xml parsing
+	parseXML: function( data ) {
+		var xml, tmp;
+		if ( !data || typeof data !== "string" ) {
+			return null;
+		}
+		try {
+			if ( window.DOMParser ) { // Standard
+				tmp = new DOMParser();
+				xml = tmp.parseFromString( data , "text/xml" );
+			} else { // IE
+				xml = new ActiveXObject( "Microsoft.XMLDOM" );
+				xml.async = "false";
+				xml.loadXML( data );
+			}
+		} catch( e ) {
+			xml = undefined;
+		}
+		if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
+			jQuery.error( "Invalid XML: " + data );
+		}
+		return xml;
+	},
+
+	noop: function() {},
+
+	// Evaluates a script in a global context
+	// Workarounds based on findings by Jim Driscoll
+	// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
+	globalEval: function( data ) {
+		if ( data && core_rnotwhite.test( data ) ) {
+			// We use execScript on Internet Explorer
+			// We use an anonymous function so that context is window
+			// rather than jQuery in Firefox
+			( window.execScript || function( data ) {
+				window[ "eval" ].call( window, data );
+			} )( data );
+		}
+	},
+
+	// Convert dashed to camelCase; used by the css and data modules
+	// Microsoft forgot to hump their vendor prefix (#9572)
+	camelCase: function( string ) {
+		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
+	},
+
+	nodeName: function( elem, name ) {
+		return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
+	},
+
+	// args is for internal usage only
+	each: function( obj, callback, args ) {
+		var name,
+			i = 0,
+			length = obj.length,
+			isObj = length === undefined || jQuery.isFunction( obj );
+
+		if ( args ) {
+			if ( isObj ) {
+				for ( name in obj ) {
+					if ( callback.apply( obj[ name ], args ) === false ) {
+						break;
+					}
+				}
+			} else {
+				for ( ; i < length; ) {
+					if ( callback.apply( obj[ i++ ], args ) === false ) {
+						break;
+					}
+				}
+			}
+
+		// A special, fast, case for the most common use of each
+		} else {
+			if ( isObj ) {
+				for ( name in obj ) {
+					if ( callback.call( obj[ name ], name, obj[ name ] ) === false ) {
+						break;
+					}
+				}
+			} else {
+				for ( ; i < length; ) {
+					if ( callback.call( obj[ i ], i, obj[ i++ ] ) === false ) {
+						break;
+					}
+				}
+			}
+		}
+
+		return obj;
+	},
+
+	// Use native String.trim function wherever possible
+	trim: core_trim && !core_trim.call("\uFEFF\xA0") ?
+		function( text ) {
+			return text == null ?
+				"" :
+				core_trim.call( text );
+		} :
+
+		// Otherwise use our own trimming functionality
+		function( text ) {
+			return text == null ?
+				"" :
+				( text + "" ).replace( rtrim, "" );
+		},
+
+	// results is for internal usage only
+	makeArray: function( arr, results ) {
+		var type,
+			ret = results || [];
+
+		if ( arr != null ) {
+			// The window, strings (and functions) also have 'length'
+			// Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
+			type = jQuery.type( arr );
+
+			if ( arr.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( arr ) ) {
+				core_push.call( ret, arr );
+			} else {
+				jQuery.merge( ret, arr );
+			}
+		}
+
+		return ret;
+	},
+
+	inArray: function( elem, arr, i ) {
+		var len;
+
+		if ( arr ) {
+			if ( core_indexOf ) {
+				return core_indexOf.call( arr, elem, i );
+			}
+
+			len = arr.length;
+			i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
+
+			for ( ; i < len; i++ ) {
+				// Skip accessing in sparse arrays
+				if ( i in arr && arr[ i ] === elem ) {
+					return i;
+				}
+			}
+		}
+
+		return -1;
+	},
+
+	merge: function( first, second ) {
+		var l = second.length,
+			i = first.length,
+			j = 0;
+
+		if ( typeof l === "number" ) {
+			for ( ; j < l; j++ ) {
+				first[ i++ ] = second[ j ];
+			}
+
+		} else {
+			while ( second[j] !== undefined ) {
+				first[ i++ ] = second[ j++ ];
+			}
+		}
+
+		first.length = i;
+
+		return first;
+	},
+
+	grep: function( elems, callback, inv ) {
+		var retVal,
+			ret = [],
+			i = 0,
+			length = elems.length;
+		inv = !!inv;
+
+		// Go through the array, only saving the items
+		// that pass the validator function
+		for ( ; i < length; i++ ) {
+			retVal = !!callback( elems[ i ], i );
+			if ( inv !== retVal ) {
+				ret.push( elems[ i ] );
+			}
+		}
+
+		return ret;
+	},
+
+	// arg is for internal usage only
+	map: function( elems, callback, arg ) {
+		var value, key,
+			ret = [],
+			i = 0,
+			length = elems.length,
+			// jquery objects are treated as arrays
+			isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;
+
+		// Go through the array, translating each of the items to their
+		if ( isArray ) {
+			for ( ; i < length; i++ ) {
+				value = callback( elems[ i ], i, arg );
+
+				if ( value != null ) {
+					ret[ ret.length ] = value;
+				}
+			}
+
+		// Go through every key on the object,
+		} else {
+			for ( key in elems ) {
+				value = callback( elems[ key ], key, arg );
+
+				if ( value != null ) {
+					ret[ ret.length ] = value;
+				}
+			}
+		}
+
+		// Flatten any nested arrays
+		return ret.concat.apply( [], ret );
+	},
+
+	// A global GUID counter for objects
+	guid: 1,
+
+	// Bind a function to a context, optionally partially applying any
+	// arguments.
+	proxy: function( fn, context ) {
+		var tmp, args, proxy;
+
+		if ( typeof context === "string" ) {
+			tmp = fn[ context ];
+			context = fn;
+			fn = tmp;
+		}
+
+		// Quick check to determine if target is callable, in the spec
+		// this throws a TypeError, but we will just return undefined.
+		if ( !jQuery.isFunction( fn ) ) {
+			return undefined;
+		}
+
+		// Simulated bind
+		args = core_slice.call( arguments, 2 );
+		proxy = function() {
+			return fn.apply( context, args.concat( core_slice.call( arguments ) ) );
+		};
+
+		// Set the guid of unique handler to the same of original handler, so it can be removed
+		proxy.guid = fn.guid = fn.guid || jQuery.guid++;
+
+		return proxy;
+	},
+
+	// Multifunctional method to get and set values of a collection
+	// The value/s can optionally be executed if it's a function
+	access: function( elems, fn, key, value, chainable, emptyGet, pass ) {
+		var exec,
+			bulk = key == null,
+			i = 0,
+			length = elems.length;
+
+		// Sets many values
+		if ( key && typeof key === "object" ) {
+			for ( i in key ) {
+				jQuery.access( elems, fn, i, key[i], 1, emptyGet, value );
+			}
+			chainable = 1;
+
+		// Sets one value
+		} else if ( value !== undefined ) {
+			// Optionally, function values get executed if exec is true
+			exec = pass === undefined && jQuery.isFunction( value );
+
+			if ( bulk ) {
+				// Bulk operations only iterate when executing function values
+				if ( exec ) {
+					exec = fn;
+					fn = function( elem, key, value ) {
+						return exec.call( jQuery( elem ), value );
+					};
+
+				// Otherwise they run against the entire set
+				} else {
+					fn.call( elems, value );
+					fn = null;
+				}
+			}
+
+			if ( fn ) {
+				for (; i < length; i++ ) {
+					fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
+				}
+			}
+
+			chainable = 1;
+		}
+
+		return chainable ?
+			elems :
+
+			// Gets
+			bulk ?
+				fn.call( elems ) :
+				length ? fn( elems[0], key ) : emptyGet;
+	},
+
+	now: function() {
+		return ( new Date() ).getTime();
+	}
+});
+
+jQuery.ready.promise = function( obj ) {
+	if ( !readyList ) {
+
+		readyList = jQuery.Deferred();
+
+		// Catch cases where $(document).ready() is called after the browser event has already occurred.
+		// we once tried to use readyState "interactive" here, but it caused issues like the one
+		// discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
+		if ( document.readyState === "complete" ) {
+			// Handle it asynchronously to allow scripts the opportunity to delay ready
+			setTimeout( jQuery.ready, 1 );
+
+		// Standards-based browsers support DOMContentLoaded
+		} else if ( document.addEventListener ) {
+			// Use the handy event callback
+			document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
+
+			// A fallback to window.onload, that will always work
+			window.addEventListener( "load", jQuery.ready, false );
+
+		// If IE event model is used
+		} else {
+			// Ensure firing before onload, maybe late but safe also for iframes
+			document.attachEvent( "onreadystatechange", DOMContentLoaded );
+
+			// A fallback to window.onload, that will always work
+			window.attachEvent( "onload", jQuery.ready );
+
+			// If IE and not a frame
+			// continually check to see if the document is ready
+			var top = false;
+
+			try {
+				top = window.frameElement == null && document.documentElement;
+			} catch(e) {}
+
+			if ( top && top.doScroll ) {
+				(function doScrollCheck() {
+					if ( !jQuery.isReady ) {
+
+						try {
+							// Use the trick by Diego Perini
+							// http://javascript.nwbox.com/IEContentLoaded/
+							top.doScroll("left");
+						} catch(e) {
+							return setTimeout( doScrollCheck, 50 );
+						}
+
+						// and execute any waiting functions
+						jQuery.ready();
+					}
+				})();
+			}
+		}
+	}
+	return readyList.promise( obj );
+};
+
+// Populate the class2type map
+jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
+	class2type[ "[object " + name + "]" ] = name.toLowerCase();
+});
+
+// All jQuery objects should point back to these
+rootjQuery = jQuery(document);
+// String to Object options format cache
+var optionsCache = {};
+
+// Convert String-formatted options into Object-formatted ones and store in cache
+function createOptions( options ) {
+	var object = optionsCache[ options ] = {};
+	jQuery.each( options.split( core_rspace ), function( _, flag ) {
+		object[ flag ] = true;
+	});
+	return object;
+}
+
+/*
+ * Create a callback list using the following parameters:
+ *
+ *	options: an optional list of space-separated options that will change how
+ *			the callback list behaves or a more traditional option object
+ *
+ * By default a callback list will act like an event callback list and can be
+ * "fired" multiple times.
+ *
+ * Possible options:
+ *
+ *	once:			will ensure the callback list can only be fired once (like a Deferred)
+ *
+ *	memory:			will keep track of previous values and will call any callback added
+ *					after the list has been fired right away with the latest "memorized"
+ *					values (like a Deferred)
+ *
+ *	unique:			will ensure a callback can only be added once (no duplicate in the list)
+ *
+ *	stopOnFalse:	interrupt callings when a callback returns false
+ *
+ */
+jQuery.Callbacks = function( options ) {
+
+	// Convert options from String-formatted to Object-formatted if needed
+	// (we check in cache first)
+	options = typeof options === "string" ?
+		( optionsCache[ options ] || createOptions( options ) ) :
+		jQuery.extend( {}, options );
+
+	var // Last fire value (for non-forgettable lists)
+		memory,
+		// Flag to know if list was already fired
+		fired,
+		// Flag to know if list is currently firing
+		firing,
+		// First callback to fire (used internally by add and fireWith)
+		firingStart,
+		// End of the loop when firing
+		firingLength,
+		// Index of currently firing callback (modified by remove if needed)
+		firingIndex,
+		// Actual callback list
+		list = [],
+		// Stack of fire calls for repeatable lists
+		stack = !options.once && [],
+		// Fire callbacks
+		fire = function( data ) {
+			memory = options.memory && data;
+			fired = true;
+			firingIndex = firingStart || 0;
+			firingStart = 0;
+			firingLength = list.length;
+			firing = true;
+			for ( ; list && firingIndex < firingLength; firingIndex++ ) {
+				if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {
+					memory = false; // To prevent further calls using add
+					break;
+				}
+			}
+			firing = false;
+			if ( list ) {
+				if ( stack ) {
+					if ( stack.length ) {
+						fire( stack.shift() );
+					}
+				} else if ( memory ) {
+					list = [];
+				} else {
+					self.disable();
+				}
+			}
+		},
+		// Actual Callbacks object
+		self = {
+			// Add a callback or a collection of callbacks to the list
+			add: function() {
+				if ( list ) {
+					// First, we save the current length
+					var start = list.length;
+					(function add( args ) {
+						jQuery.each( args, function( _, arg ) {
+							var type = jQuery.type( arg );
+							if ( type === "function" && ( !options.unique || !self.has( arg ) ) ) {
+								list.push( arg );
+							} else if ( arg && arg.length && type !== "string" ) {
+								// Inspect recursively
+								add( arg );
+							}
+						});
+					})( arguments );
+					// Do we need to add the callbacks to the
+					// current firing batch?
+					if ( firing ) {
+						firingLength = list.length;
+					// With memory, if we're not firing then
+					// we should call right away
+					} else if ( memory ) {
+						firingStart = start;
+						fire( memory );
+					}
+				}
+				return this;
+			},
+			// Remove a callback from the list
+			remove: function() {
+				if ( list ) {
+					jQuery.each( arguments, function( _, arg ) {
+						var index;
+						while( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
+							list.splice( index, 1 );
+							// Handle firing indexes
+							if ( firing ) {
+								if ( index <= firingLength ) {
+									firingLength--;
+								}
+								if ( index <= firingIndex ) {
+									firingIndex--;
+								}
+							}
+						}
+					});
+				}
+				return this;
+			},
+			// Control if a given callback is in the list
+			has: function( fn ) {
+				return jQuery.inArray( fn, list ) > -1;
+			},
+			// Remove all callbacks from the list
+			empty: function() {
+				list = [];
+				return this;
+			},
+			// Have the list do nothing anymore
+			disable: function() {
+				list = stack = memory = undefined;
+				return this;
+			},
+			// Is it disabled?
+			disabled: function() {
+				return !list;
+			},
+			// Lock the list in its current state
+			lock: function() {
+				stack = undefined;
+				if ( !memory ) {
+					self.disable();
+				}
+				return this;
+			},
+			// Is it locked?
+			locked: function() {
+				return !stack;
+			},
+			// Call all callbacks with the given context and arguments
+			fireWith: function( context, args ) {
+				args = args || [];
+				args = [ context, args.slice ? args.slice() : args ];
+				if ( list && ( !fired || stack ) ) {
+					if ( firing ) {
+						stack.push( args );
+					} else {
+						fire( args );
+					}
+				}
+				return this;
+			},
+			// Call all the callbacks with the given arguments
+			fire: function() {
+				self.fireWith( this, arguments );
+				return this;
+			},
+			// To know if the callbacks have already been called at least once
+			fired: function() {
+				return !!fired;
+			}
+		};
+
+	return self;
+};
+jQuery.extend({
+
+	Deferred: function( func ) {
+		var tuples = [
+				// action, add listener, listener list, final state
+				[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
+				[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
+				[ "notify", "progress", jQuery.Callbacks("memory") ]
+			],
+			state = "pending",
+			promise = {
+				state: function() {
+					return state;
+				},
+				always: function() {
+					deferred.done( arguments ).fail( arguments );
+					return this;
+				},
+				then: function( /* fnDone, fnFail, fnProgress */ ) {
+					var fns = arguments;
+					return jQuery.Deferred(function( newDefer ) {
+						jQuery.each( tuples, function( i, tuple ) {
+							var action = tuple[ 0 ],
+								fn = fns[ i ];
+							// deferred[ done | fail | progress ] for forwarding actions to newDefer
+							deferred[ tuple[1] ]( jQuery.isFunction( fn ) ?
+								function() {
+									var returned = fn.apply( this, arguments );
+									if ( returned && jQuery.isFunction( returned.promise ) ) {
+										returned.promise()
+											.done( newDefer.resolve )
+											.fail( newDefer.reject )
+											.progress( newDefer.notify );
+									} else {
+										newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] );
+									}
+								} :
+								newDefer[ action ]
+							);
+						});
+						fns = null;
+					}).promise();
+				},
+				// Get a promise for this deferred
+				// If obj is provided, the promise aspect is added to the object
+				promise: function( obj ) {
+					return obj != null ? jQuery.extend( obj, promise ) : promise;
+				}
+			},
+			deferred = {};
+
+		// Keep pipe for back-compat
+		promise.pipe = promise.then;
+
+		// Add list-specific methods
+		jQuery.each( tuples, function( i, tuple ) {
+			var list = tuple[ 2 ],
+				stateString = tuple[ 3 ];
+
+			// promise[ done | fail | progress ] = list.add
+			promise[ tuple[1] ] = list.add;
+
+			// Handle state
+			if ( stateString ) {
+				list.add(function() {
+					// state = [ resolved | rejected ]
+					state = stateString;
+
+				// [ reject_list | resolve_list ].disable; progress_list.lock
+				}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
+			}
+
+			// deferred[ resolve | reject | notify ] = list.fire
+			deferred[ tuple[0] ] = list.fire;
+			deferred[ tuple[0] + "With" ] = list.fireWith;
+		});
+
+		// Make the deferred a promise
+		promise.promise( deferred );
+
+		// Call given func if any
+		if ( func ) {
+			func.call( deferred, deferred );
+		}
+
+		// All done!
+		return deferred;
+	},
+
+	// Deferred helper
+	when: function( subordinate /* , ..., subordinateN */ ) {
+		var i = 0,
+			resolveValues = core_slice.call( arguments ),
+			length = resolveValues.length,
+
+			// the count of uncompleted subordinates
+			remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
+
+			// the master Deferred. If resolveValues consist of only a single Deferred, just use that.
+			deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
+
+			// Update function for both resolve and progress values
+			updateFunc = function( i, contexts, values ) {
+				return function( value ) {
+					contexts[ i ] = this;
+					values[ i ] = arguments.length > 1 ? core_slice.call( arguments ) : value;
+					if( values === progressValues ) {
+						deferred.notifyWith( contexts, values );
+					} else if ( !( --remaining ) ) {
+						deferred.resolveWith( contexts, values );
+					}
+				};
+			},
+
+			progressValues, progressContexts, resolveContexts;
+
+		// add listeners to Deferred subordinates; treat others as resolved
+		if ( length > 1 ) {
+			progressValues = new Array( length );
+			progressContexts = new Array( length );
+			resolveContexts = new Array( length );
+			for ( ; i < length; i++ ) {
+				if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
+					resolveValues[ i ].promise()
+						.done( updateFunc( i, resolveContexts, resolveValues ) )
+						.fail( deferred.reject )
+						.progress( updateFunc( i, progressContexts, progressValues ) );
+				} else {
+					--remaining;
+				}
+			}
+		}
+
+		// if we're not waiting on anything, resolve the master
+		if ( !remaining ) {
+			deferred.resolveWith( resolveContexts, resolveValues );
+		}
+
+		return deferred.promise();
+	}
+});
+jQuery.support = (function() {
+
+	var support,
+		all,
+		a,
+		select,
+		opt,
+		input,
+		fragment,
+		eventName,
+		i,
+		isSupported,
+		clickFn,
+		div = document.createElement("div");
+
+	// Preliminary tests
+	div.setAttribute( "className", "t" );
+	div.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
+
+	all = div.getElementsByTagName("*");
+	a = div.getElementsByTagName("a")[ 0 ];
+	a.style.cssText = "top:1px;float:left;opacity:.5";
+
+	// Can't get basic test support
+	if ( !all || !all.length ) {
+		return {};
+	}
+
+	// First batch of supports tests
+	select = document.createElement("select");
+	opt = select.appendChild( document.createElement("option") );
+	input = div.getElementsByTagName("input")[ 0 ];
+
+	support = {
+		// IE strips leading whitespace when .innerHTML is used
+		leadingWhitespace: ( div.firstChild.nodeType === 3 ),
+
+		// Make sure that tbody elements aren't automatically inserted
+		// IE will insert them into empty tables
+		tbody: !div.getElementsByTagName("tbody").length,
+
+		// Make sure that link elements get serialized correctly by innerHTML
+		// This requires a wrapper element in IE
+		htmlSerialize: !!div.getElementsByTagName("link").length,
+
+		// Get the style information from getAttribute
+		// (IE uses .cssText instead)
+		style: /top/.test( a.getAttribute("style") ),
+
+		// Make sure that URLs aren't manipulated
+		// (IE normalizes it by default)
+		hrefNormalized: ( a.getAttribute("href") === "/a" ),
+
+		// Make sure that element opacity exists
+		// (IE uses filter instead)
+		// Use a regex to work around a WebKit issue. See #5145
+		opacity: /^0.5/.test( a.style.opacity ),
+
+		// Verify style float existence
+		// (IE uses styleFloat instead of cssFloat)
+		cssFloat: !!a.style.cssFloat,
+
+		// Make sure that if no value is specified for a checkbox
+		// that it defaults to "on".
+		// (WebKit defaults to "" instead)
+		checkOn: ( input.value === "on" ),
+
+		// Make sure that a selected-by-default option has a working selected property.
+		// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
+		optSelected: opt.selected,
+
+		// Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
+		getSetAttribute: div.className !== "t",
+
+		// Tests for enctype support on a form(#6743)
+		enctype: !!document.createElement("form").enctype,
+
+		// Makes sure cloning an html5 element does not cause problems
+		// Where outerHTML is undefined, this still works
+		html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav></:nav>",
+
+		// jQuery.support.boxModel DEPRECATED in 1.8 since we don't support Quirks Mode
+		boxModel: ( document.compatMode === "CSS1Compat" ),
+
+		// Will be defined later
+		submitBubbles: true,
+		changeBubbles: true,
+		focusinBubbles: false,
+		deleteExpando: true,
+		noCloneEvent: true,
+		inlineBlockNeedsLayout: false,
+		shrinkWrapBlocks: false,
+		reliableMarginRight: true,
+		boxSizingReliable: true,
+		pixelPosition: false
+	};
+
+	// Make sure checked status is properly cloned
+	input.checked = true;
+	support.noCloneChecked = input.cloneNode( true ).checked;
+
+	// Make sure that the options inside disabled selects aren't marked as disabled
+	// (WebKit marks them as disabled)
+	select.disabled = true;
+	support.optDisabled = !opt.disabled;
+
+	// Test to see if it's possible to delete an expando from an element
+	// Fails in Internet Explorer
+	try {
+		delete div.test;
+	} catch( e ) {
+		support.deleteExpando = false;
+	}
+
+	if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
+		div.attachEvent( "onclick", clickFn = function() {
+			// Cloning a node shouldn't copy over any
+			// bound event handlers (IE does this)
+			support.noCloneEvent = false;
+		});
+		div.cloneNode( true ).fireEvent("onclick");
+		div.detachEvent( "onclick", clickFn );
+	}
+
+	// Check if a radio maintains its value
+	// after being appended to the DOM
+	input = document.createElement("input");
+	input.value = "t";
+	input.setAttribute( "type", "radio" );
+	support.radioValue = input.value === "t";
+
+	input.setAttribute( "checked", "checked" );
+
+	// #11217 - WebKit loses check when the name is after the checked attribute
+	input.setAttribute( "name", "t" );
+
+	div.appendChild( input );
+	fragment = document.createDocumentFragment();
+	fragment.appendChild( div.lastChild );
+
+	// WebKit doesn't clone checked state correctly in fragments
+	support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
+
+	// Check if a disconnected checkbox will retain its checked
+	// value of true after appended to the DOM (IE6/7)
+	support.appendChecked = input.checked;
+
+	fragment.removeChild( input );
+	fragment.appendChild( div );
+
+	// Technique from Juriy Zaytsev
+	// http://perfectionkills.com/detecting-event-support-without-browser-sniffing/
+	// We only care about the case where non-standard event systems
+	// are used, namely in IE. Short-circuiting here helps us to
+	// avoid an eval call (in setAttribute) which can cause CSP
+	// to go haywire. See: https://developer.mozilla.org/en/Security/CSP
+	if ( div.attachEvent ) {
+		for ( i in {
+			submit: true,
+			change: true,
+			focusin: true
+		}) {
+			eventName = "on" + i;
+			isSupported = ( eventName in div );
+			if ( !isSupported ) {
+				div.setAttribute( eventName, "return;" );
+				isSupported = ( typeof div[ eventName ] === "function" );
+			}
+			support[ i + "Bubbles" ] = isSupported;
+		}
+	}
+
+	// Run tests that need a body at doc ready
+	jQuery(function() {
+		var container, div, tds, marginDiv,
+			divReset = "padding:0;margin:0;border:0;display:block;overflow:hidden;",
+			body = document.getElementsByTagName("body")[0];
+
+		if ( !body ) {
+			// Return for frameset docs that don't have a body
+			return;
+		}
+
+		container = document.createElement("div");
+		container.style.cssText = "visibility:hidden;border:0;width:0;height:0;position:static;top:0;margin-top:1px";
+		body.insertBefore( container, body.firstChild );
+
+		// Construct the test element
+		div = document.createElement("div");
+		container.appendChild( div );
+
+		// Check if table cells still have offsetWidth/Height when they are set
+		// to display:none and there are still other visible table cells in a
+		// table row; if so, offsetWidth/Height are not reliable for use when
+		// determining if an element has been hidden directly using
+		// display:none (it is still safe to use offsets if a parent element is
+		// hidden; don safety goggles and see bug #4512 for more information).
+		// (only IE 8 fails this test)
+		div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>";
+		tds = div.getElementsByTagName("td");
+		tds[ 0 ].style.cssText = "padding:0;margin:0;border:0;display:none";
+		isSupported = ( tds[ 0 ].offsetHeight === 0 );
+
+		tds[ 0 ].style.display = "";
+		tds[ 1 ].style.display = "none";
+
+		// Check if empty table cells still have offsetWidth/Height
+		// (IE <= 8 fail this test)
+		support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
+
+		// Check box-sizing and margin behavior
+		div.innerHTML = "";
+		div.style.cssText = "box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;";
+		support.boxSizing = ( div.offsetWidth === 4 );
+		support.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== 1 );
+
+		// NOTE: To any future maintainer, we've window.getComputedStyle
+		// because jsdom on node.js will break without it.
+		if ( window.getComputedStyle ) {
+			support.pixelPosition = ( window.getComputedStyle( div, null ) || {} ).top !== "1%";
+			support.boxSizingReliable = ( window.getComputedStyle( div, null ) || { width: "4px" } ).width === "4px";
+
+			// Check if div with explicit width and no margin-right incorrectly
+			// gets computed margin-right based on width of container. For more
+			// info see bug #3333
+			// Fails in WebKit before Feb 2011 nightlies
+			// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
+			marginDiv = document.createElement("div");
+			marginDiv.style.cssText = div.style.cssText = divReset;
+			marginDiv.style.marginRight = marginDiv.style.width = "0";
+			div.style.width = "1px";
+			div.appendChild( marginDiv );
+			support.reliableMarginRight =
+				!parseFloat( ( window.getComputedStyle( marginDiv, null ) || {} ).marginRight );
+		}
+
+		if ( typeof div.style.zoom !== "undefined" ) {
+			// Check if natively block-level elements act like inline-block
+			// elements when setting their display to 'inline' and giving
+			// them layout
+			// (IE < 8 does this)
+			div.innerHTML = "";
+			div.style.cssText = divReset + "width:1px;padding:1px;display:inline;zoom:1";
+			support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 );
+
+			// Check if elements with layout shrink-wrap their children
+			// (IE 6 does this)
+			div.style.display = "block";
+			div.style.overflow = "visible";
+			div.innerHTML = "<div></div>";
+			div.firstChild.style.width = "5px";
+			support.shrinkWrapBlocks = ( div.offsetWidth !== 3 );
+
+			container.style.zoom = 1;
+		}
+
+		// Null elements to avoid leaks in IE
+		body.removeChild( container );
+		container = div = tds = marginDiv = null;
+	});
+
+	// Null elements to avoid leaks in IE
+	fragment.removeChild( div );
+	all = a = select = opt = input = fragment = div = null;
+
+	return support;
+})();
+var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/,
+	rmultiDash = /([A-Z])/g;
+
+jQuery.extend({
+	cache: {},
+
+	deletedIds: [],
+
+	// Remove at next major release (1.9/2.0)
+	uuid: 0,
+
+	// Unique for each copy of jQuery on the page
+	// Non-digits removed to match rinlinejQuery
+	expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
+
+	// The following elements throw uncatchable exceptions if you
+	// attempt to add expando properties to them.
+	noData: {
+		"embed": true,
+		// Ban all objects except for Flash (which handle expandos)
+		"object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
+		"applet": true
+	},
+
+	hasData: function( elem ) {
+		elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
+		return !!elem && !isEmptyDataObject( elem );
+	},
+
+	data: function( elem, name, data, pvt /* Internal Use Only */ ) {
+		if ( !jQuery.acceptData( elem ) ) {
+			return;
+		}
+
+		var thisCache, ret,
+			internalKey = jQuery.expando,
+			getByName = typeof name === "string",
+
+			// We have to handle DOM nodes and JS objects differently because IE6-7
+			// can't GC object references properly across the DOM-JS boundary
+			isNode = elem.nodeType,
+
+			// Only DOM nodes need the global jQuery cache; JS object data is
+			// attached directly to the object so GC can occur automatically
+			cache = isNode ? jQuery.cache : elem,
+
+			// Only defining an ID for JS objects if its cache already exists allows
+			// the code to shortcut on the same path as a DOM node with no cache
+			id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey;
+
+		// Avoid doing any more work than we need to when trying to get data on an
+		// object that has no data at all
+		if ( (!id || !cache[id] || (!pvt && !cache[id].data)) && getByName && data === undefined ) {
+			return;
+		}
+
+		if ( !id ) {
+			// Only DOM nodes need a new unique ID for each element since their data
+			// ends up in the global cache
+			if ( isNode ) {
+				elem[ internalKey ] = id = jQuery.deletedIds.pop() || jQuery.guid++;
+			} else {
+				id = internalKey;
+			}
+		}
+
+		if ( !cache[ id ] ) {
+			cache[ id ] = {};
+
+			// Avoids exposing jQuery metadata on plain JS objects when the object
+			// is serialized using JSON.stringify
+			if ( !isNode ) {
+				cache[ id ].toJSON = jQuery.noop;
+			}
+		}
+
+		// An object can be passed to jQuery.data instead of a key/value pair; this gets
+		// shallow copied over onto the existing cache
+		if ( typeof name === "object" || typeof name === "function" ) {
+			if ( pvt ) {
+				cache[ id ] = jQuery.extend( cache[ id ], name );
+			} else {
+				cache[ id ].data = jQuery.extend( cache[ id ].data, name );
+			}
+		}
+
+		thisCache = cache[ id ];
+
+		// jQuery data() is stored in a separate object inside the object's internal data
+		// cache in order to avoid key collisions between internal data and user-defined
+		// data.
+		if ( !pvt ) {
+			if ( !thisCache.data ) {
+				thisCache.data = {};
+			}
+
+			thisCache = thisCache.data;
+		}
+
+		if ( data !== undefined ) {
+			thisCache[ jQuery.camelCase( name ) ] = data;
+		}
+
+		// Check for both converted-to-camel and non-converted data property names
+		// If a data property was specified
+		if ( getByName ) {
+
+			// First Try to find as-is property data
+			ret = thisCache[ name ];
+
+			// Test for null|undefined property data
+			if ( ret == null ) {
+
+				// Try to find the camelCased property
+				ret = thisCache[ jQuery.camelCase( name ) ];
+			}
+		} else {
+			ret = thisCache;
+		}
+
+		return ret;
+	},
+
+	removeData: function( elem, name, pvt /* Internal Use Only */ ) {
+		if ( !jQuery.acceptData( elem ) ) {
+			return;
+		}
+
+		var thisCache, i, l,
+
+			isNode = elem.nodeType,
+
+			// See jQuery.data for more information
+			cache = isNode ? jQuery.cache : elem,
+			id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
+
+		// If there is already no cache entry for this object, there is no
+		// purpose in continuing
+		if ( !cache[ id ] ) {
+			return;
+		}
+
+		if ( name ) {
+
+			thisCache = pvt ? cache[ id ] : cache[ id ].data;
+
+			if ( thisCache ) {
+
+				// Support array or space separated string names for data keys
+				if ( !jQuery.isArray( name ) ) {
+
+					// try the string as a key before any manipulation
+					if ( name in thisCache ) {
+						name = [ name ];
+					} else {
+
+						// split the camel cased version by spaces unless a key with the spaces exists
+						name = jQuery.camelCase( name );
+						if ( name in thisCache ) {
+							name = [ name ];
+						} else {
+							name = name.split(" ");
+						}
+					}
+				}
+
+				for ( i = 0, l = name.length; i < l; i++ ) {
+					delete thisCache[ name[i] ];
+				}
+
+				// If there is no data left in the cache, we want to continue
+				// and let the cache object itself get destroyed
+				if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) {
+					return;
+				}
+			}
+		}
+
+		// See jQuery.data for more information
+		if ( !pvt ) {
+			delete cache[ id ].data;
+
+			// Don't destroy the parent cache unless the internal data object
+			// had been the only thing left in it
+			if ( !isEmptyDataObject( cache[ id ] ) ) {
+				return;
+			}
+		}
+
+		// Destroy the cache
+		if ( isNode ) {
+			jQuery.cleanData( [ elem ], true );
+
+		// Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)
+		} else if ( jQuery.support.deleteExpando || cache != cache.window ) {
+			delete cache[ id ];
+
+		// When all else fails, null
+		} else {
+			cache[ id ] = null;
+		}
+	},
+
+	// For internal use only.
+	_data: function( elem, name, data ) {
+		return jQuery.data( elem, name, data, true );
+	},
+
+	// A method for determining if a DOM node can handle the data expando
+	acceptData: function( elem ) {
+		var noData = elem.nodeName && jQuery.noData[ elem.nodeName.toLowerCase() ];
+
+		// nodes accept data unless otherwise specified; rejection can be conditional
+		return !noData || noData !== true && elem.getAttribute("classid") === noData;
+	}
+});
+
+jQuery.fn.extend({
+	data: function( key, value ) {
+		var parts, part, attr, name, l,
+			elem = this[0],
+			i = 0,
+			data = null;
+
+		// Gets all values
+		if ( key === undefined ) {
+			if ( this.length ) {
+				data = jQuery.data( elem );
+
+				if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) {
+					attr = elem.attributes;
+					for ( l = attr.length; i < l; i++ ) {
+						name = attr[i].name;
+
+						if ( !name.indexOf( "data-" ) ) {
+							name = jQuery.camelCase( name.substring(5) );
+
+							dataAttr( elem, name, data[ name ] );
+						}
+					}
+					jQuery._data( elem, "parsedAttrs", true );
+				}
+			}
+
+			return data;
+		}
+
+		// Sets multiple values
+		if ( typeof key === "object" ) {
+			return this.each(function() {
+				jQuery.data( this, key );
+			});
+		}
+
+		parts = key.split( ".", 2 );
+		parts[1] = parts[1] ? "." + parts[1] : "";
+		part = parts[1] + "!";
+
+		return jQuery.access( this, function( value ) {
+
+			if ( value === undefined ) {
+				data = this.triggerHandler( "getData" + part, [ parts[0] ] );
+
+				// Try to fetch any internally stored data first
+				if ( data === undefined && elem ) {
+					data = jQuery.data( elem, key );
+					data = dataAttr( elem, key, data );
+				}
+
+				return data === undefined && parts[1] ?
+					this.data( parts[0] ) :
+					data;
+			}
+
+			parts[1] = value;
+			this.each(function() {
+				var self = jQuery( this );
+
+				self.triggerHandler( "setData" + part, parts );
+				jQuery.data( this, key, value );
+				self.triggerHandler( "changeData" + part, parts );
+			});
+		}, null, value, arguments.length > 1, null, false );
+	},
+
+	removeData: function( key ) {
+		return this.each(function() {
+			jQuery.removeData( this, key );
+		});
+	}
+});
+
+function dataAttr( elem, key, data ) {
+	// If nothing was found internally, try to fetch any
+	// data from the HTML5 data-* attribute
+	if ( data === undefined && elem.nodeType === 1 ) {
+
+		var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
+
+		data = elem.getAttribute( name );
+
+		if ( typeof data === "string" ) {
+			try {
+				data = data === "true" ? true :
+				data === "false" ? false :
+				data === "null" ? null :
+				// Only convert to a number if it doesn't change the string
+				+data + "" === data ? +data :
+				rbrace.test( data ) ? jQuery.parseJSON( data ) :
+					data;
+			} catch( e ) {}
+
+			// Make sure we set the data so it isn't changed later
+			jQuery.data( elem, key, data );
+
+		} else {
+			data = undefined;
+		}
+	}
+
+	return data;
+}
+
+// checks a cache object for emptiness
+function isEmptyDataObject( obj ) {
+	var name;
+	for ( name in obj ) {
+
+		// if the public data object is empty, the private is still empty
+		if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
+			continue;
+		}
+		if ( name !== "toJSON" ) {
+			return false;
+		}
+	}
+
+	return true;
+}
+jQuery.extend({
+	queue: function( elem, type, data ) {
+		var queue;
+
+		if ( elem ) {
+			type = ( type || "fx" ) + "queue";
+			queue = jQuery._data( elem, type );
+
+			// Speed up dequeue by getting out quickly if this is just a lookup
+			if ( data ) {
+				if ( !queue || jQuery.isArray(data) ) {
+					queue = jQuery._data( elem, type, jQuery.makeArray(data) );
+				} else {
+					queue.push( data );
+				}
+			}
+			return queue || [];
+		}
+	},
+
+	dequeue: function( elem, type ) {
+		type = type || "fx";
+
+		var queue = jQuery.queue( elem, type ),
+			startLength = queue.length,
+			fn = queue.shift(),
+			hooks = jQuery._queueHooks( elem, type ),
+			next = function() {
+				jQuery.dequeue( elem, type );
+			};
+
+		// If the fx queue is dequeued, always remove the progress sentinel
+		if ( fn === "inprogress" ) {
+			fn = queue.shift();
+			startLength--;
+		}
+
+		if ( fn ) {
+
+			// Add a progress sentinel to prevent the fx queue from being
+			// automatically dequeued
+			if ( type === "fx" ) {
+				queue.unshift( "inprogress" );
+			}
+
+			// clear up the last queue stop function
+			delete hooks.stop;
+			fn.call( elem, next, hooks );
+		}
+
+		if ( !startLength && hooks ) {
+			hooks.empty.fire();
+		}
+	},
+
+	// not intended for public consumption - generates a queueHooks object, or returns the current one
+	_queueHooks: function( elem, type ) {
+		var key = type + "queueHooks";
+		return jQuery._data( elem, key ) || jQuery._data( elem, key, {
+			empty: jQuery.Callbacks("once memory").add(function() {
+				jQuery.removeData( elem, type + "queue", true );
+				jQuery.removeData( elem, key, true );
+			})
+		});
+	}
+});
+
+jQuery.fn.extend({
+	queue: function( type, data ) {
+		var setter = 2;
+
+		if ( typeof type !== "string" ) {
+			data = type;
+			type = "fx";
+			setter--;
+		}
+
+		if ( arguments.length < setter ) {
+			return jQuery.queue( this[0], type );
+		}
+
+		return data === undefined ?
+			this :
+			this.each(function() {
+				var queue = jQuery.queue( this, type, data );
+
+				// ensure a hooks for this queue
+				jQuery._queueHooks( this, type );
+
+				if ( type === "fx" && queue[0] !== "inprogress" ) {
+					jQuery.dequeue( this, type );
+				}
+			});
+	},
+	dequeue: function( type ) {
+		return this.each(function() {
+			jQuery.dequeue( this, type );
+		});
+	},
+	// Based off of the plugin by Clint Helfers, with permission.
+	// http://blindsignals.com/index.php/2009/07/jquery-delay/
+	delay: function( time, type ) {
+		time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
+		type = type || "fx";
+
+		return this.queue( type, function( next, hooks ) {
+			var timeout = setTimeout( next, time );
+			hooks.stop = function() {
+				clearTimeout( timeout );
+			};
+		});
+	},
+	clearQueue: function( type ) {
+		return this.queue( type || "fx", [] );
+	},
+	// Get a promise resolved when queues of a certain type
+	// are emptied (fx is the type by default)
+	promise: function( type, obj ) {
+		var tmp,
+			count = 1,
+			defer = jQuery.Deferred(),
+			elements = this,
+			i = this.length,
+			resolve = function() {
+				if ( !( --count ) ) {
+					defer.resolveWith( elements, [ elements ] );
+				}
+			};
+
+		if ( typeof type !== "string" ) {
+			obj = type;
+			type = undefined;
+		}
+		type = type || "fx";
+
+		while( i-- ) {
+			tmp = jQuery._data( elements[ i ], type + "queueHooks" );
+			if ( tmp && tmp.empty ) {
+				count++;
+				tmp.empty.add( resolve );
+			}
+		}
+		resolve();
+		return defer.promise( obj );
+	}
+});
+var nodeHook, boolHook, fixSpecified,
+	rclass = /[\t\r\n]/g,
+	rreturn = /\r/g,
+	rtype = /^(?:button|input)$/i,
+	rfocusable = /^(?:button|input|object|select|textarea)$/i,
+	rclickable = /^a(?:rea|)$/i,
+	rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
+	getSetAttribute = jQuery.support.getSetAttribute;
+
+jQuery.fn.extend({
+	attr: function( name, value ) {
+		return jQuery.access( this, jQuery.attr, name, value, arguments.length > 1 );
+	},
+
+	removeAttr: function( name ) {
+		return this.each(function() {
+			jQuery.removeAttr( this, name );
+		});
+	},
+
+	prop: function( name, value ) {
+		return jQuery.access( this, jQuery.prop, name, value, arguments.length > 1 );
+	},
+
+	removeProp: function( name ) {
+		name = jQuery.propFix[ name ] || name;
+		return this.each(function() {
+			// try/catch handles cases where IE balks (such as removing a property on window)
+			try {
+				this[ name ] = undefined;
+				delete this[ name ];
+			} catch( e ) {}
+		});
+	},
+
+	addClass: function( value ) {
+		var classNames, i, l, elem,
+			setClass, c, cl;
+
+		if ( jQuery.isFunction( value ) ) {
+			return this.each(function( j ) {
+				jQuery( this ).addClass( value.call(this, j, this.className) );
+			});
+		}
+
+		if ( value && typeof value === "string" ) {
+			classNames = value.split( core_rspace );
+
+			for ( i = 0, l = this.length; i < l; i++ ) {
+				elem = this[ i ];
+
+				if ( elem.nodeType === 1 ) {
+					if ( !elem.className && classNames.length === 1 ) {
+						elem.className = value;
+
+					} else {
+						setClass = " " + elem.className + " ";
+
+						for ( c = 0, cl = classNames.length; c < cl; c++ ) {
+							if ( setClass.indexOf( " " + classNames[ c ] + " " ) < 0 ) {
+								setClass += classNames[ c ] + " ";
+							}
+						}
+						elem.className = jQuery.trim( setClass );
+					}
+				}
+			}
+		}
+
+		return this;
+	},
+
+	removeClass: function( value ) {
+		var removes, className, elem, c, cl, i, l;
+
+		if ( jQuery.isFunction( value ) ) {
+			return this.each(function( j ) {
+				jQuery( this ).removeClass( value.call(this, j, this.className) );
+			});
+		}
+		if ( (value && typeof value === "string") || value === undefined ) {
+			removes = ( value || "" ).split( core_rspace );
+
+			for ( i = 0, l = this.length; i < l; i++ ) {
+				elem = this[ i ];
+				if ( elem.nodeType === 1 && elem.className ) {
+
+					className = (" " + elem.className + " ").replace( rclass, " " );
+
+					// loop over each item in the removal list
+					for ( c = 0, cl = removes.length; c < cl; c++ ) {
+						// Remove until there is nothing to remove,
+						while ( className.indexOf(" " + removes[ c ] + " ") >= 0 ) {
+							className = className.replace( " " + removes[ c ] + " " , " " );
+						}
+					}
+					elem.className = value ? jQuery.trim( className ) : "";
+				}
+			}
+		}
+
+		return this;
+	},
+
+	toggleClass: function( value, stateVal ) {
+		var type = typeof value,
+			isBool = typeof stateVal === "boolean";
+
+		if ( jQuery.isFunction( value ) ) {
+			return this.each(function( i ) {
+				jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
+			});
+		}
+
+		return this.each(function() {
+			if ( type === "string" ) {
+				// toggle individual class names
+				var className,
+					i = 0,
+					self = jQuery( this ),
+					state = stateVal,
+					classNames = value.split( core_rspace );
+
+				while ( (className = classNames[ i++ ]) ) {
+					// check each className given, space separated list
+					state = isBool ? state : !self.hasClass( className );
+					self[ state ? "addClass" : "removeClass" ]( className );
+				}
+
+			} else if ( type === "undefined" || type === "boolean" ) {
+				if ( this.className ) {
+					// store className if set
+					jQuery._data( this, "__className__", this.className );
+				}
+
+				// toggle whole className
+				this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
+			}
+		});
+	},
+
+	hasClass: function( selector ) {
+		var className = " " + selector + " ",
+			i = 0,
+			l = this.length;
+		for ( ; i < l; i++ ) {
+			if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) >= 0 ) {
+				return true;
+			}
+		}
+
+		return false;
+	},
+
+	val: function( value ) {
+		var hooks, ret, isFunction,
+			elem = this[0];
+
+		if ( !arguments.length ) {
+			if ( elem ) {
+				hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ];
+
+				if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
+					return ret;
+				}
+
+				ret = elem.value;
+
+				return typeof ret === "string" ?
+					// handle most common string cases
+					ret.replace(rreturn, "") :
+					// handle cases where value is null/undef or number
+					ret == null ? "" : ret;
+			}
+
+			return;
+		}
+
+		isFunction = jQuery.isFunction( value );
+
+		return this.each(function( i ) {
+			var val,
+				self = jQuery(this);
+
+			if ( this.nodeType !== 1 ) {
+				return;
+			}
+
+			if ( isFunction ) {
+				val = value.call( this, i, self.val() );
+			} else {
+				val = value;
+			}
+
+			// Treat null/undefined as ""; convert numbers to string
+			if ( val == null ) {
+				val = "";
+			} else if ( typeof val === "number" ) {
+				val += "";
+			} else if ( jQuery.isArray( val ) ) {
+				val = jQuery.map(val, function ( value ) {
+					return value == null ? "" : value + "";
+				});
+			}
+
+			hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
+
+			// If set returns undefined, fall back to normal setting
+			if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
+				this.value = val;
+			}
+		});
+	}
+});
+
+jQuery.extend({
+	valHooks: {
+		option: {
+			get: function( elem ) {
+				// attributes.value is undefined in Blackberry 4.7 but
+				// uses .value. See #6932
+				var val = elem.attributes.value;
+				return !val || val.specified ? elem.value : elem.text;
+			}
+		},
+		select: {
+			get: function( elem ) {
+				var value, i, max, option,
+					index = elem.selectedIndex,
+					values = [],
+					options = elem.options,
+					one = elem.type === "select-one";
+
+				// Nothing was selected
+				if ( index < 0 ) {
+					return null;
+				}
+
+				// Loop through all the selected options
+				i = one ? index : 0;
+				max = one ? index + 1 : options.length;
+				for ( ; i < max; i++ ) {
+					option = options[ i ];
+
+					// Don't return options that are disabled or in a disabled optgroup
+					if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
+							(!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
+
+						// Get the specific value for the option
+						value = jQuery( option ).val();
+
+						// We don't need an array for one selects
+						if ( one ) {
+							return value;
+						}
+
+						// Multi-Selects return an array
+						values.push( value );
+					}
+				}
+
+				// Fixes Bug #2551 -- select.val() broken in IE after form.reset()
+				if ( one && !values.length && options.length ) {
+					return jQuery( options[ index ] ).val();
+				}
+
+				return values;
+			},
+
+			set: function( elem, value ) {
+				var values = jQuery.makeArray( value );
+
+				jQuery(elem).find("option").each(function() {
+					this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
+				});
+
+				if ( !values.length ) {
+					elem.selectedIndex = -1;
+				}
+				return values;
+			}
+		}
+	},
+
+	// Unused in 1.8, left in so attrFn-stabbers won't die; remove in 1.9
+	attrFn: {},
+
+	attr: function( elem, name, value, pass ) {
+		var ret, hooks, notxml,
+			nType = elem.nodeType;
+
+		// don't get/set attributes on text, comment and attribute nodes
+		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
+			return;
+		}
+
+		if ( pass && jQuery.isFunction( jQuery.fn[ name ] ) ) {
+			return jQuery( elem )[ name ]( value );
+		}
+
+		// Fallback to prop when attributes are not supported
+		if ( typeof elem.getAttribute === "undefined" ) {
+			return jQuery.prop( elem, name, value );
+		}
+
+		notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
+
+		// All attributes are lowercase
+		// Grab necessary hook if one is defined
+		if ( notxml ) {
+			name = name.toLowerCase();
+			hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook );
+		}
+
+		if ( value !== undefined ) {
+
+			if ( value === null ) {
+				jQuery.removeAttr( elem, name );
+				return;
+
+			} else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
+				return ret;
+
+			} else {
+				elem.setAttribute( name, value + "" );
+				return value;
+			}
+
+		} else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) {
+			return ret;
+
+		} else {
+
+			ret = elem.getAttribute( name );
+
+			// Non-existent attributes return null, we normalize to undefined
+			return ret === null ?
+				undefined :
+				ret;
+		}
+	},
+
+	removeAttr: function( elem, value ) {
+		var propName, attrNames, name, isBool,
+			i = 0;
+
+		if ( value && elem.nodeType === 1 ) {
+
+			attrNames = value.split( core_rspace );
+
+			for ( ; i < attrNames.length; i++ ) {
+				name = attrNames[ i ];
+
+				if ( name ) {
+					propName = jQuery.propFix[ name ] || name;
+					isBool = rboolean.test( name );
+
+					// See #9699 for explanation of this approach (setting first, then removal)
+					// Do not do this for boolean attributes (see #10870)
+					if ( !isBool ) {
+						jQuery.attr( elem, name, "" );
+					}
+					elem.removeAttribute( getSetAttribute ? name : propName );
+
+					// Set corresponding property to false for boolean attributes
+					if ( isBool && propName in elem ) {
+						elem[ propName ] = false;
+					}
+				}
+			}
+		}
+	},
+
+	attrHooks: {
+		type: {
+			set: function( elem, value ) {
+				// We can't allow the type property to be changed (since it causes problems in IE)
+				if ( rtype.test( elem.nodeName ) && elem.parentNode ) {
+					jQuery.error( "type property can't be changed" );
+				} else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
+					// Setting the type on a radio button after the value resets the value in IE6-9
+					// Reset value to it's default in case type is set after value
+					// This is for element creation
+					var val = elem.value;
+					elem.setAttribute( "type", value );
+					if ( val ) {
+						elem.value = val;
+					}
+					return value;
+				}
+			}
+		},
+		// Use the value property for back compat
+		// Use the nodeHook for button elements in IE6/7 (#1954)
+		value: {
+			get: function( elem, name ) {
+				if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
+					return nodeHook.get( elem, name );
+				}
+				return name in elem ?
+					elem.value :
+					null;
+			},
+			set: function( elem, value, name ) {
+				if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
+					return nodeHook.set( elem, value, name );
+				}
+				// Does not return so that setAttribute is also used
+				elem.value = value;
+			}
+		}
+	},
+
+	propFix: {
+		tabindex: "tabIndex",
+		readonly: "readOnly",
+		"for": "htmlFor",
+		"class": "className",
+		maxlength: "maxLength",
+		cellspacing: "cellSpacing",
+		cellpadding: "cellPadding",
+		rowspan: "rowSpan",
+		colspan: "colSpan",
+		usemap: "useMap",
+		frameborder: "frameBorder",
+		contenteditable: "contentEditable"
+	},
+
+	prop: function( elem, name, value ) {
+		var ret, hooks, notxml,
+			nType = elem.nodeType;
+
+		// don't get/set properties on text, comment and attribute nodes
+		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
+			return;
+		}
+
+		notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
+
+		if ( notxml ) {
+			// Fix name and attach hooks
+			name = jQuery.propFix[ name ] || name;
+			hooks = jQuery.propHooks[ name ];
+		}
+
+		if ( value !== undefined ) {
+			if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
+				return ret;
+
+			} else {
+				return ( elem[ name ] = value );
+			}
+
+		} else {
+			if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
+				return ret;
+
+			} else {
+				return elem[ name ];
+			}
+		}
+	},
+
+	propHooks: {
+		tabIndex: {
+			get: function( elem ) {
+				// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
+				// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
+				var attributeNode = elem.getAttributeNode("tabindex");
+
+				return attributeNode && attributeNode.specified ?
+					parseInt( attributeNode.value, 10 ) :
+					rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
+						0 :
+						undefined;
+			}
+		}
+	}
+});
+
+// Hook for boolean attributes
+boolHook = {
+	get: function( elem, name ) {
+		// Align boolean attributes with corresponding properties
+		// Fall back to attribute presence where some booleans are not supported
+		var attrNode,
+			property = jQuery.prop( elem, name );
+		return property === true || typeof property !== "boolean" && ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ?
+			name.toLowerCase() :
+			undefined;
+	},
+	set: function( elem, value, name ) {
+		var propName;
+		if ( value === false ) {
+			// Remove boolean attributes when set to false
+			jQuery.removeAttr( elem, name );
+		} else {
+			// value is true since we know at this point it's type boolean and not false
+			// Set boolean attributes to the same name and set the DOM property
+			propName = jQuery.propFix[ name ] || name;
+			if ( propName in elem ) {
+				// Only set the IDL specifically if it already exists on the element
+				elem[ propName ] = true;
+			}
+
+			elem.setAttribute( name, name.toLowerCase() );
+		}
+		return name;
+	}
+};
+
+// IE6/7 do not support getting/setting some attributes with get/setAttribute
+if ( !getSetAttribute ) {
+
+	fixSpecified = {
+		name: true,
+		id: true,
+		coords: true
+	};
+
+	// Use this for any attribute in IE6/7
+	// This fixes almost every IE6/7 issue
+	nodeHook = jQuery.valHooks.button = {
+		get: function( elem, name ) {
+			var ret;
+			ret = elem.getAttributeNode( name );
+			return ret && ( fixSpecified[ name ] ? ret.value !== "" : ret.specified ) ?
+				ret.value :
+				undefined;
+		},
+		set: function( elem, value, name ) {
+			// Set the existing or create a new attribute node
+			var ret = elem.getAttributeNode( name );
+			if ( !ret ) {
+				ret = document.createAttribute( name );
+				elem.setAttributeNode( ret );
+			}
+			return ( ret.value = value + "" );
+		}
+	};
+
+	// Set width and height to auto instead of 0 on empty string( Bug #8150 )
+	// This is for removals
+	jQuery.each([ "width", "height" ], function( i, name ) {
+		jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
+			set: function( elem, value ) {
+				if ( value === "" ) {
+					elem.setAttribute( name, "auto" );
+					return value;
+				}
+			}
+		});
+	});
+
+	// Set contenteditable to false on removals(#10429)
+	// Setting to empty string throws an error as an invalid value
+	jQuery.attrHooks.contenteditable = {
+		get: nodeHook.get,
+		set: function( elem, value, name ) {
+			if ( value === "" ) {
+				value = "false";
+			}
+			nodeHook.set( elem, value, name );
+		}
+	};
+}
+
+
+// Some attributes require a special call on IE
+if ( !jQuery.support.hrefNormalized ) {
+	jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
+		jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
+			get: function( elem ) {
+				var ret = elem.getAttribute( name, 2 );
+				return ret === null ? undefined : ret;
+			}
+		});
+	});
+}
+
+if ( !jQuery.support.style ) {
+	jQuery.attrHooks.style = {
+		get: function( elem ) {
+			// Return undefined in the case of empty string
+			// Normalize to lowercase since IE uppercases css property names
+			return elem.style.cssText.toLowerCase() || undefined;
+		},
+		set: function( elem, value ) {
+			return ( elem.style.cssText = value + "" );
+		}
+	};
+}
+
+// Safari mis-reports the default selected property of an option
+// Accessing the parent's selectedIndex property fixes it
+if ( !jQuery.support.optSelected ) {
+	jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
+		get: function( elem ) {
+			var parent = elem.parentNode;
+
+			if ( parent ) {
+				parent.selectedIndex;
+
+				// Make sure that it also works with optgroups, see #5701
+				if ( parent.parentNode ) {
+					parent.parentNode.selectedIndex;
+				}
+			}
+			return null;
+		}
+	});
+}
+
+// IE6/7 call enctype encoding
+if ( !jQuery.support.enctype ) {
+	jQuery.propFix.enctype = "encoding";
+}
+
+// Radios and checkboxes getter/setter
+if ( !jQuery.support.checkOn ) {
+	jQuery.each([ "radio", "checkbox" ], function() {
+		jQuery.valHooks[ this ] = {
+			get: function( elem ) {
+				// Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
+				return elem.getAttribute("value") === null ? "on" : elem.value;
+			}
+		};
+	});
+}
+jQuery.each([ "radio", "checkbox" ], function() {
+	jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
+		set: function( elem, value ) {
+			if ( jQuery.isArray( value ) ) {
+				return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
+			}
+		}
+	});
+});
+var rformElems = /^(?:textarea|input|select)$/i,
+	rtypenamespace = /^([^\.]*|)(?:\.(.+)|)$/,
+	rhoverHack = /(?:^|\s)hover(\.\S+|)\b/,
+	rkeyEvent = /^key/,
+	rmouseEvent = /^(?:mouse|contextmenu)|click/,
+	rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
+	hoverHack = function( events ) {
+		return jQuery.event.special.hover ? events : events.replace( rhoverHack, "mouseenter$1 mouseleave$1" );
+	};
+
+/*
+ * Helper functions for managing events -- not part of the public interface.
+ * Props to Dean Edwards' addEvent library for many of the ideas.
+ */
+jQuery.event = {
+
+	add: function( elem, types, handler, data, selector ) {
+
+		var elemData, eventHandle, events,
+			t, tns, type, namespaces, handleObj,
+			handleObjIn, handlers, special;
+
+		// Don't attach events to noData or text/comment nodes (allow plain objects tho)
+		if ( elem.nodeType === 3 || elem.nodeType === 8 || !types || !handler || !(elemData = jQuery._data( elem )) ) {
+			return;
+		}
+
+		// Caller can pass in an object of custom data in lieu of the handler
+		if ( handler.handler ) {
+			handleObjIn = handler;
+			handler = handleObjIn.handler;
+			selector = handleObjIn.selector;
+		}
+
+		// Make sure that the handler has a unique ID, used to find/remove it later
+		if ( !handler.guid ) {
+			handler.guid = jQuery.guid++;
+		}
+
+		// Init the element's event structure and main handler, if this is the first
+		events = elemData.events;
+		if ( !events ) {
+			elemData.events = events = {};
+		}
+		eventHandle = elemData.handle;
+		if ( !eventHandle ) {
+			elemData.handle = eventHandle = function( e ) {
+				// Discard the second event of a jQuery.event.trigger() and
+				// when an event is called after a page has unloaded
+				return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
+					jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
+					undefined;
+			};
+			// Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
+			eventHandle.elem = elem;
+		}
+
+		// Handle multiple events separated by a space
+		// jQuery(...).bind("mouseover mouseout", fn);
+		types = jQuery.trim( hoverHack(types) ).split( " " );
+		for ( t = 0; t < types.length; t++ ) {
+
+			tns = rtypenamespace.exec( types[t] ) || [];
+			type = tns[1];
+			namespaces = ( tns[2] || "" ).split( "." ).sort();
+
+			// If event changes its type, use the special event handlers for the changed type
+			special = jQuery.event.special[ type ] || {};
+
+			// If selector defined, determine special event api type, otherwise given type
+			type = ( selector ? special.delegateType : special.bindType ) || type;
+
+			// Update special based on newly reset type
+			special = jQuery.event.special[ type ] || {};
+
+			// handleObj is passed to all event handlers
+			handleObj = jQuery.extend({
+				type: type,
+				origType: tns[1],
+				data: data,
+				handler: handler,
+				guid: handler.guid,
+				selector: selector,
+				needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
+				namespace: namespaces.join(".")
+			}, handleObjIn );
+
+			// Init the event handler queue if we're the first
+			handlers = events[ type ];
+			if ( !handlers ) {
+				handlers = events[ type ] = [];
+				handlers.delegateCount = 0;
+
+				// Only use addEventListener/attachEvent if the special events handler returns false
+				if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
+					// Bind the global event handler to the element
+					if ( elem.addEventListener ) {
+						elem.addEventListener( type, eventHandle, false );
+
+					} else if ( elem.attachEvent ) {
+						elem.attachEvent( "on" + type, eventHandle );
+					}
+				}
+			}
+
+			if ( special.add ) {
+				special.add.call( elem, handleObj );
+
+				if ( !handleObj.handler.guid ) {
+					handleObj.handler.guid = handler.guid;
+				}
+			}
+
+			// Add to the element's handler list, delegates in front
+			if ( selector ) {
+				handlers.splice( handlers.delegateCount++, 0, handleObj );
+			} else {
+				handlers.push( handleObj );
+			}
+
+			// Keep track of which events have ever been used, for event optimization
+			jQuery.event.global[ type ] = true;
+		}
+
+		// Nullify elem to prevent memory leaks in IE
+		elem = null;
+	},
+
+	global: {},
+
+	// Detach an event or set of events from an element
+	remove: function( elem, types, handler, selector, mappedTypes ) {
+
+		var t, tns, type, origType, namespaces, origCount,
+			j, events, special, eventType, handleObj,
+			elemData = jQuery.hasData( elem ) && jQuery._data( elem );
+
+		if ( !elemData || !(events = elemData.events) ) {
+			return;
+		}
+
+		// Once for each type.namespace in types; type may be omitted
+		types = jQuery.trim( hoverHack( types || "" ) ).split(" ");
+		for ( t = 0; t < types.length; t++ ) {
+			tns = rtypenamespace.exec( types[t] ) || [];
+			type = origType = tns[1];
+			namespaces = tns[2];
+
+			// Unbind all events (on this namespace, if provided) for the element
+			if ( !type ) {
+				for ( type in events ) {
+					jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
+				}
+				continue;
+			}
+
+			special = jQuery.event.special[ type ] || {};
+			type = ( selector? special.delegateType : special.bindType ) || type;
+			eventType = events[ type ] || [];
+			origCount = eventType.length;
+			namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.|)") + "(\\.|$)") : null;
+
+			// Remove matching events
+			for ( j = 0; j < eventType.length; j++ ) {
+				handleObj = eventType[ j ];
+
+				if ( ( mappedTypes || origType === handleObj.origType ) &&
+					 ( !handler || handler.guid === handleObj.guid ) &&
+					 ( !namespaces || namespaces.test( handleObj.namespace ) ) &&
+					 ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
+					eventType.splice( j--, 1 );
+
+					if ( handleObj.selector ) {
+						eventType.delegateCount--;
+					}
+					if ( special.remove ) {
+						special.remove.call( elem, handleObj );
+					}
+				}
+			}
+
+			// Remove generic event handler if we removed something and no more handlers exist
+			// (avoids potential for endless recursion during removal of special event handlers)
+			if ( eventType.length === 0 && origCount !== eventType.length ) {
+				if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
+					jQuery.removeEvent( elem, type, elemData.handle );
+				}
+
+				delete events[ type ];
+			}
+		}
+
+		// Remove the expando if it's no longer used
+		if ( jQuery.isEmptyObject( events ) ) {
+			delete elemData.handle;
+
+			// removeData also checks for emptiness and clears the expando if empty
+			// so use it instead of delete
+			jQuery.removeData( elem, "events", true );
+		}
+	},
+
+	// Events that are safe to short-circuit if no handlers are attached.
+	// Native DOM events should not be added, they may have inline handlers.
+	customEvent: {
+		"getData": true,
+		"setData": true,
+		"changeData": true
+	},
+
+	trigger: function( event, data, elem, onlyHandlers ) {
+		// Don't do events on text and comment nodes
+		if ( elem && (elem.nodeType === 3 || elem.nodeType === 8) ) {
+			return;
+		}
+
+		// Event object or event type
+		var cache, exclusive, i, cur, old, ontype, special, handle, eventPath, bubbleType,
+			type = event.type || event,
+			namespaces = [];
+
+		// focus/blur morphs to focusin/out; ensure we're not firing them right now
+		if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
+			return;
+		}
+
+		if ( type.indexOf( "!" ) >= 0 ) {
+			// Exclusive events trigger only for the exact event (no namespaces)
+			type = type.slice(0, -1);
+			exclusive = true;
+		}
+
+		if ( type.indexOf( "." ) >= 0 ) {
+			// Namespaced trigger; create a regexp to match event type in handle()
+			namespaces = type.split(".");
+			type = namespaces.shift();
+			namespaces.sort();
+		}
+
+		if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
+			// No jQuery handlers for this event type, and it can't have inline handlers
+			return;
+		}
+
+		// Caller can pass in an Event, Object, or just an event type string
+		event = typeof event === "object" ?
+			// jQuery.Event object
+			event[ jQuery.expando ] ? event :
+			// Object literal
+			new jQuery.Event( type, event ) :
+			// Just the event type (string)
+			new jQuery.Event( type );
+
+		event.type = type;
+		event.isTrigger = true;
+		event.exclusive = exclusive;
+		event.namespace = namespaces.join( "." );
+		event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null;
+		ontype = type.indexOf( ":" ) < 0 ? "on" + type : "";
+
+		// Handle a global trigger
+		if ( !elem ) {
+
+			// TODO: Stop taunting the data cache; remove global events and always attach to document
+			cache = jQuery.cache;
+			for ( i in cache ) {
+				if ( cache[ i ].events && cache[ i ].events[ type ] ) {
+					jQuery.event.trigger( event, data, cache[ i ].handle.elem, true );
+				}
+			}
+			return;
+		}
+
+		// Clean up the event in case it is being reused
+		event.result = undefined;
+		if ( !event.target ) {
+			event.target = elem;
+		}
+
+		// Clone any incoming data and prepend the event, creating the handler arg list
+		data = data != null ? jQuery.makeArray( data ) : [];
+		data.unshift( event );
+
+		// Allow special events to draw outside the lines
+		special = jQuery.event.special[ type ] || {};
+		if ( special.trigger && special.trigger.apply( elem, data ) === false ) {
+			return;
+		}
+
+		// Determine event propagation path in advance, per W3C events spec (#9951)
+		// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
+		eventPath = [[ elem, special.bindType || type ]];
+		if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
+
+			bubbleType = special.delegateType || type;
+			cur = rfocusMorph.test( bubbleType + type ) ? elem : elem.parentNode;
+			for ( old = elem; cur; cur = cur.parentNode ) {
+				eventPath.push([ cur, bubbleType ]);
+				old = cur;
+			}
+
+			// Only add window if we got to document (e.g., not plain obj or detached DOM)
+			if ( old === (elem.ownerDocument || document) ) {
+				eventPath.push([ old.defaultView || old.parentWindow || window, bubbleType ]);
+			}
+		}
+
+		// Fire handlers on the event path
+		for ( i = 0; i < eventPath.length && !event.isPropagationStopped(); i++ ) {
+
+			cur = eventPath[i][0];
+			event.type = eventPath[i][1];
+
+			handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" );
+			if ( handle ) {
+				handle.apply( cur, data );
+			}
+			// Note that this is a bare JS function and not a jQuery handler
+			handle = ontype && cur[ ontype ];
+			if ( handle && jQuery.acceptData( cur ) && handle.apply && handle.apply( cur, data ) === false ) {
+				event.preventDefault();
+			}
+		}
+		event.type = type;
+
+		// If nobody prevented the default action, do it now
+		if ( !onlyHandlers && !event.isDefaultPrevented() ) {
+
+			if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) &&
+				!(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
+
+				// Call a native DOM method on the target with the same name name as the event.
+				// Can't use an .isFunction() check here because IE6/7 fails that test.
+				// Don't do default actions on window, that's where global variables be (#6170)
+				// IE<9 dies on focus/blur to hidden element (#1486)
+				if ( ontype && elem[ type ] && ((type !== "focus" && type !== "blur") || event.target.offsetWidth !== 0) && !jQuery.isWindow( elem ) ) {
+
+					// Don't re-trigger an onFOO event when we call its FOO() method
+					old = elem[ ontype ];
+
+					if ( old ) {
+						elem[ ontype ] = null;
+					}
+
+					// Prevent re-triggering of the same event, since we already bubbled it above
+					jQuery.event.triggered = type;
+					elem[ type ]();
+					jQuery.event.triggered = undefined;
+
+					if ( old ) {
+						elem[ ontype ] = old;
+					}
+				}
+			}
+		}
+
+		return event.result;
+	},
+
+	dispatch: function( event ) {
+
+		// Make a writable jQuery.Event from the native event object
+		event = jQuery.event.fix( event || window.event );
+
+		var i, j, cur, ret, selMatch, matched, matches, handleObj, sel, related,
+			handlers = ( (jQuery._data( this, "events" ) || {} )[ event.type ] || []),
+			delegateCount = handlers.delegateCount,
+			args = core_slice.call( arguments ),
+			run_all = !event.exclusive && !event.namespace,
+			special = jQuery.event.special[ event.type ] || {},
+			handlerQueue = [];
+
+		// Use the fix-ed jQuery.Event rather than the (read-only) native event
+		args[0] = event;
+		event.delegateTarget = this;
+
+		// Call the preDispatch hook for the mapped type, and let it bail if desired
+		if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
+			return;
+		}
+
+		// Determine handlers that should run if there are delegated events
+		// Avoid non-left-click bubbling in Firefox (#3861)
+		if ( delegateCount && !(event.button && event.type === "click") ) {
+
+			for ( cur = event.target; cur != this; cur = cur.parentNode || this ) {
+
+				// Don't process clicks (ONLY) on disabled elements (#6911, #8165, #11382, #11764)
+				if ( cur.disabled !== true || event.type !== "click" ) {
+					selMatch = {};
+					matches = [];
+					for ( i = 0; i < delegateCount; i++ ) {
+						handleObj = handlers[ i ];
+						sel = handleObj.selector;
+
+						if ( selMatch[ sel ] === undefined ) {
+							selMatch[ sel ] = handleObj.needsContext ?
+								jQuery( sel, this ).index( cur ) >= 0 :
+								jQuery.find( sel, this, null, [ cur ] ).length;
+						}
+						if ( selMatch[ sel ] ) {
+							matches.push( handleObj );
+						}
+					}
+					if ( matches.length ) {
+						handlerQueue.push({ elem: cur, matches: matches });
+					}
+				}
+			}
+		}
+
+		// Add the remaining (directly-bound) handlers
+		if ( handlers.length > delegateCount ) {
+			handlerQueue.push({ elem: this, matches: handlers.slice( delegateCount ) });
+		}
+
+		// Run delegates first; they may want to stop propagation beneath us
+		for ( i = 0; i < handlerQueue.length && !event.isPropagationStopped(); i++ ) {
+			matched = handlerQueue[ i ];
+			event.currentTarget = matched.elem;
+
+			for ( j = 0; j < matched.matches.length && !event.isImmediatePropagationStopped(); j++ ) {
+				handleObj = matched.matches[ j ];
+
+				// Triggered event must either 1) be non-exclusive and have no namespace, or
+				// 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
+				if ( run_all || (!event.namespace && !handleObj.namespace) || event.namespace_re && event.namespace_re.test( handleObj.namespace ) ) {
+
+					event.data = handleObj.data;
+					event.handleObj = handleObj;
+
+					ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
+							.apply( matched.elem, args );
+
+					if ( ret !== undefined ) {
+						event.result = ret;
+						if ( ret === false ) {
+							event.preventDefault();
+							event.stopPropagation();
+						}
+					}
+				}
+			}
+		}
+
+		// Call the postDispatch hook for the mapped type
+		if ( special.postDispatch ) {
+			special.postDispatch.call( this, event );
+		}
+
+		return event.result;
+	},
+
+	// Includes some event props shared by KeyEvent and MouseEvent
+	// *** attrChange attrName relatedNode srcElement  are not normalized, non-W3C, deprecated, will be removed in 1.8 ***
+	props: "attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
+
+	fixHooks: {},
+
+	keyHooks: {
+		props: "char charCode key keyCode".split(" "),
+		filter: function( event, original ) {
+
+			// Add which for key events
+			if ( event.which == null ) {
+				event.which = original.charCode != null ? original.charCode : original.keyCode;
+			}
+
+			return event;
+		}
+	},
+
+	mouseHooks: {
+		props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
+		filter: function( event, original ) {
+			var eventDoc, doc, body,
+				button = original.button,
+				fromElement = original.fromElement;
+
+			// Calculate pageX/Y if missing and clientX/Y available
+			if ( event.pageX == null && original.clientX != null ) {
+				eventDoc = event.target.ownerDocument || document;
+				doc = eventDoc.documentElement;
+				body = eventDoc.body;
+
+				event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
+				event.pageY = original.clientY + ( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) - ( doc && doc.clientTop  || body && body.clientTop  || 0 );
+			}
+
+			// Add relatedTarget, if necessary
+			if ( !event.relatedTarget && fromElement ) {
+				event.relatedTarget = fromElement === event.target ? original.toElement : fromElement;
+			}
+
+			// Add which for click: 1 === left; 2 === middle; 3 === right
+			// Note: button is not normalized, so don't use it
+			if ( !event.which && button !== undefined ) {
+				event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
+			}
+
+			return event;
+		}
+	},
+
+	fix: function( event ) {
+		if ( event[ jQuery.expando ] ) {
+			return event;
+		}
+
+		// Create a writable copy of the event object and normalize some properties
+		var i, prop,
+			originalEvent = event,
+			fixHook = jQuery.event.fixHooks[ event.type ] || {},
+			copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
+
+		event = jQuery.Event( originalEvent );
+
+		for ( i = copy.length; i; ) {
+			prop = copy[ --i ];
+			event[ prop ] = originalEvent[ prop ];
+		}
+
+		// Fix target property, if necessary (#1925, IE 6/7/8 & Safari2)
+		if ( !event.target ) {
+			event.target = originalEvent.srcElement || document;
+		}
+
+		// Target should not be a text node (#504, Safari)
+		if ( event.target.nodeType === 3 ) {
+			event.target = event.target.parentNode;
+		}
+
+		// For mouse/key events, metaKey==false if it's undefined (#3368, #11328; IE6/7/8)
+		event.metaKey = !!event.metaKey;
+
+		return fixHook.filter? fixHook.filter( event, originalEvent ) : event;
+	},
+
+	special: {
+		load: {
+			// Prevent triggered image.load events from bubbling to window.load
+			noBubble: true
+		},
+
+		focus: {
+			delegateType: "focusin"
+		},
+		blur: {
+			delegateType: "focusout"
+		},
+
+		beforeunload: {
+			setup: function( data, namespaces, eventHandle ) {
+				// We only want to do this special case on windows
+				if ( jQuery.isWindow( this ) ) {
+					this.onbeforeunload = eventHandle;
+				}
+			},
+
+			teardown: function( namespaces, eventHandle ) {
+				if ( this.onbeforeunload === eventHandle ) {
+					this.onbeforeunload = null;
+				}
+			}
+		}
+	},
+
+	simulate: function( type, elem, event, bubble ) {
+		// Piggyback on a donor event to simulate a different one.
+		// Fake originalEvent to avoid donor's stopPropagation, but if the
+		// simulated event prevents default then we do the same on the donor.
+		var e = jQuery.extend(
+			new jQuery.Event(),
+			event,
+			{ type: type,
+				isSimulated: true,
+				originalEvent: {}
+			}
+		);
+		if ( bubble ) {
+			jQuery.event.trigger( e, null, elem );
+		} else {
+			jQuery.event.dispatch.call( elem, e );
+		}
+		if ( e.isDefaultPrevented() ) {
+			event.preventDefault();
+		}
+	}
+};
+
+// Some plugins are using, but it's undocumented/deprecated and will be removed.
+// The 1.7 special event interface should provide all the hooks needed now.
+jQuery.event.handle = jQuery.event.dispatch;
+
+jQuery.removeEvent = document.removeEventListener ?
+	function( elem, type, handle ) {
+		if ( elem.removeEventListener ) {
+			elem.removeEventListener( type, handle, false );
+		}
+	} :
+	function( elem, type, handle ) {
+		var name = "on" + type;
+
+		if ( elem.detachEvent ) {
+
+			// #8545, #7054, preventing memory leaks for custom events in IE6-8 –
+			// detachEvent needed property on element, by name of that event, to properly expose it to GC
+			if ( typeof elem[ name ] === "undefined" ) {
+				elem[ name ] = null;
+			}
+
+			elem.detachEvent( name, handle );
+		}
+	};
+
+jQuery.Event = function( src, props ) {
+	// Allow instantiation without the 'new' keyword
+	if ( !(this instanceof jQuery.Event) ) {
+		return new jQuery.Event( src, props );
+	}
+
+	// Event object
+	if ( src && src.type ) {
+		this.originalEvent = src;
+		this.type = src.type;
+
+		// Events bubbling up the document may have been marked as prevented
+		// by a handler lower down the tree; reflect the correct value.
+		this.isDefaultPrevented = ( src.defaultPrevented || src.returnValue === false ||
+			src.getPreventDefault && src.getPreventDefault() ) ? returnTrue : returnFalse;
+
+	// Event type
+	} else {
+		this.type = src;
+	}
+
+	// Put explicitly provided properties onto the event object
+	if ( props ) {
+		jQuery.extend( this, props );
+	}
+
+	// Create a timestamp if incoming event doesn't have one
+	this.timeStamp = src && src.timeStamp || jQuery.now();
+
+	// Mark it as fixed
+	this[ jQuery.expando ] = true;
+};
+
+function returnFalse() {
+	return false;
+}
+function returnTrue() {
+	return true;
+}
+
+// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
+// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
+jQuery.Event.prototype = {
+	preventDefault: function() {
+		this.isDefaultPrevented = returnTrue;
+
+		var e = this.originalEvent;
+		if ( !e ) {
+			return;
+		}
+
+		// if preventDefault exists run it on the original event
+		if ( e.preventDefault ) {
+			e.preventDefault();
+
+		// otherwise set the returnValue property of the original event to false (IE)
+		} else {
+			e.returnValue = false;
+		}
+	},
+	stopPropagation: function() {
+		this.isPropagationStopped = returnTrue;
+
+		var e = this.originalEvent;
+		if ( !e ) {
+			return;
+		}
+		// if stopPropagation exists run it on the original event
+		if ( e.stopPropagation ) {
+			e.stopPropagation();
+		}
+		// otherwise set the cancelBubble property of the original event to true (IE)
+		e.cancelBubble = true;
+	},
+	stopImmediatePropagation: function() {
+		this.isImmediatePropagationStopped = returnTrue;
+		this.stopPropagation();
+	},
+	isDefaultPrevented: returnFalse,
+	isPropagationStopped: returnFalse,
+	isImmediatePropagationStopped: returnFalse
+};
+
+// Create mouseenter/leave events using mouseover/out and event-time checks
+jQuery.each({
+	mouseenter: "mouseover",
+	mouseleave: "mouseout"
+}, function( orig, fix ) {
+	jQuery.event.special[ orig ] = {
+		delegateType: fix,
+		bindType: fix,
+
+		handle: function( event ) {
+			var ret,
+				target = this,
+				related = event.relatedTarget,
+				handleObj = event.handleObj,
+				selector = handleObj.selector;
+
+			// For mousenter/leave call the handler if related is outside the target.
+			// NB: No relatedTarget if the mouse left/entered the browser window
+			if ( !related || (related !== target && !jQuery.contains( target, related )) ) {
+				event.type = handleObj.origType;
+				ret = handleObj.handler.apply( this, arguments );
+				event.type = fix;
+			}
+			return ret;
+		}
+	};
+});
+
+// IE submit delegation
+if ( !jQuery.support.submitBubbles ) {
+
+	jQuery.event.special.submit = {
+		setup: function() {
+			// Only need this for delegated form submit events
+			if ( jQuery.nodeName( this, "form" ) ) {
+				return false;
+			}
+
+			// Lazy-add a submit handler when a descendant form may potentially be submitted
+			jQuery.event.add( this, "click._submit keypress._submit", function( e ) {
+				// Node name check avoids a VML-related crash in IE (#9807)
+				var elem = e.target,
+					form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined;
+				if ( form && !jQuery._data( form, "_submit_attached" ) ) {
+					jQuery.event.add( form, "submit._submit", function( event ) {
+						event._submit_bubble = true;
+					});
+					jQuery._data( form, "_submit_attached", true );
+				}
+			});
+			// return undefined since we don't need an event listener
+		},
+
+		postDispatch: function( event ) {
+			// If form was submitted by the user, bubble the event up the tree
+			if ( event._submit_bubble ) {
+				delete event._submit_bubble;
+				if ( this.parentNode && !event.isTrigger ) {
+					jQuery.event.simulate( "submit", this.parentNode, event, true );
+				}
+			}
+		},
+
+		teardown: function() {
+			// Only need this for delegated form submit events
+			if ( jQuery.nodeName( this, "form" ) ) {
+				return false;
+			}
+
+			// Remove delegated handlers; cleanData eventually reaps submit handlers attached above
+			jQuery.event.remove( this, "._submit" );
+		}
+	};
+}
+
+// IE change delegation and checkbox/radio fix
+if ( !jQuery.support.changeBubbles ) {
+
+	jQuery.event.special.change = {
+
+		setup: function() {
+
+			if ( rformElems.test( this.nodeName ) ) {
+				// IE doesn't fire change on a check/radio until blur; trigger it on click
+				// after a propertychange. Eat the blur-change in special.change.handle.
+				// This still fires onchange a second time for check/radio after blur.
+				if ( this.type === "checkbox" || this.type === "radio" ) {
+					jQuery.event.add( this, "propertychange._change", function( event ) {
+						if ( event.originalEvent.propertyName === "checked" ) {
+							this._just_changed = true;
+						}
+					});
+					jQuery.event.add( this, "click._change", function( event ) {
+						if ( this._just_changed && !event.isTrigger ) {
+							this._just_changed = false;
+						}
+						// Allow triggered, simulated change events (#11500)
+						jQuery.event.simulate( "change", this, event, true );
+					});
+				}
+				return false;
+			}
+			// Delegated event; lazy-add a change handler on descendant inputs
+			jQuery.event.add( this, "beforeactivate._change", function( e ) {
+				var elem = e.target;
+
+				if ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, "_change_attached" ) ) {
+					jQuery.event.add( elem, "change._change", function( event ) {
+						if ( this.parentNode && !event.isSimulated && !event.isTrigger ) {
+							jQuery.event.simulate( "change", this.parentNode, event, true );
+						}
+					});
+					jQuery._data( elem, "_change_attached", true );
+				}
+			});
+		},
+
+		handle: function( event ) {
+			var elem = event.target;
+
+			// Swallow native change events from checkbox/radio, we already triggered them above
+			if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) {
+				return event.handleObj.handler.apply( this, arguments );
+			}
+		},
+
+		teardown: function() {
+			jQuery.event.remove( this, "._change" );
+
+			return !rformElems.test( this.nodeName );
+		}
+	};
+}
+
+// Create "bubbling" focus and blur events
+if ( !jQuery.support.focusinBubbles ) {
+	jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
+
+		// Attach a single capturing handler while someone wants focusin/focusout
+		var attaches = 0,
+			handler = function( event ) {
+				jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true );
+			};
+
+		jQuery.event.special[ fix ] = {
+			setup: function() {
+				if ( attaches++ === 0 ) {
+					document.addEventListener( orig, handler, true );
+				}
+			},
+			teardown: function() {
+				if ( --attaches === 0 ) {
+					document.removeEventListener( orig, handler, true );
+				}
+			}
+		};
+	});
+}
+
+jQuery.fn.extend({
+
+	on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
+		var origFn, type;
+
+		// Types can be a map of types/handlers
+		if ( typeof types === "object" ) {
+			// ( types-Object, selector, data )
+			if ( typeof selector !== "string" ) { // && selector != null
+				// ( types-Object, data )
+				data = data || selector;
+				selector = undefined;
+			}
+			for ( type in types ) {
+				this.on( type, selector, data, types[ type ], one );
+			}
+			return this;
+		}
+
+		if ( data == null && fn == null ) {
+			// ( types, fn )
+			fn = selector;
+			data = selector = undefined;
+		} else if ( fn == null ) {
+			if ( typeof selector === "string" ) {
+				// ( types, selector, fn )
+				fn = data;
+				data = undefined;
+			} else {
+				// ( types, data, fn )
+				fn = data;
+				data = selector;
+				selector = undefined;
+			}
+		}
+		if ( fn === false ) {
+			fn = returnFalse;
+		} else if ( !fn ) {
+			return this;
+		}
+
+		if ( one === 1 ) {
+			origFn = fn;
+			fn = function( event ) {
+				// Can use an empty set, since event contains the info
+				jQuery().off( event );
+				return origFn.apply( this, arguments );
+			};
+			// Use same guid so caller can remove using origFn
+			fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
+		}
+		return this.each( function() {
+			jQuery.event.add( this, types, fn, data, selector );
+		});
+	},
+	one: function( types, selector, data, fn ) {
+		return this.on( types, selector, data, fn, 1 );
+	},
+	off: function( types, selector, fn ) {
+		var handleObj, type;
+		if ( types && types.preventDefault && types.handleObj ) {
+			// ( event )  dispatched jQuery.Event
+			handleObj = types.handleObj;
+			jQuery( types.delegateTarget ).off(
+				handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType,
+				handleObj.selector,
+				handleObj.handler
+			);
+			return this;
+		}
+		if ( typeof types === "object" ) {
+			// ( types-object [, selector] )
+			for ( type in types ) {
+				this.off( type, selector, types[ type ] );
+			}
+			return this;
+		}
+		if ( selector === false || typeof selector === "function" ) {
+			// ( types [, fn] )
+			fn = selector;
+			selector = undefined;
+		}
+		if ( fn === false ) {
+			fn = returnFalse;
+		}
+		return this.each(function() {
+			jQuery.event.remove( this, types, fn, selector );
+		});
+	},
+
+	bind: function( types, data, fn ) {
+		return this.on( types, null, data, fn );
+	},
+	unbind: function( types, fn ) {
+		return this.off( types, null, fn );
+	},
+
+	live: function( types, data, fn ) {
+		jQuery( this.context ).on( types, this.selector, data, fn );
+		return this;
+	},
+	die: function( types, fn ) {
+		jQuery( this.context ).off( types, this.selector || "**", fn );
+		return this;
+	},
+
+	delegate: function( selector, types, data, fn ) {
+		return this.on( types, selector, data, fn );
+	},
+	undelegate: function( selector, types, fn ) {
+		// ( namespace ) or ( selector, types [, fn] )
+		return arguments.length === 1 ? this.off( selector, "**" ) : this.off( types, selector || "**", fn );
+	},
+
+	trigger: function( type, data ) {
+		return this.each(function() {
+			jQuery.event.trigger( type, data, this );
+		});
+	},
+	triggerHandler: function( type, data ) {
+		if ( this[0] ) {
+			return jQuery.event.trigger( type, data, this[0], true );
+		}
+	},
+
+	toggle: function( fn ) {
+		// Save reference to arguments for access in closure
+		var args = arguments,
+			guid = fn.guid || jQuery.guid++,
+			i = 0,
+			toggler = function( event ) {
+				// Figure out which function to execute
+				var lastToggle = ( jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i;
+				jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 );
+
+				// Make sure that clicks stop
+				event.preventDefault();
+
+				// and execute the function
+				return args[ lastToggle ].apply( this, arguments ) || false;
+			};
+
+		// link all the functions, so any of them can unbind this click handler
+		toggler.guid = guid;
+		while ( i < args.length ) {
+			args[ i++ ].guid = guid;
+		}
+
+		return this.click( toggler );
+	},
+
+	hover: function( fnOver, fnOut ) {
+		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
+	}
+});
+
+jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
+	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
+	"change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) {
+
+	// Handle event binding
+	jQuery.fn[ name ] = function( data, fn ) {
+		if ( fn == null ) {
+			fn = data;
+			data = null;
+		}
+
+		return arguments.length > 0 ?
+			this.on( name, null, data, fn ) :
+			this.trigger( name );
+	};
+
+	if ( rkeyEvent.test( name ) ) {
+		jQuery.event.fixHooks[ name ] = jQuery.event.keyHooks;
+	}
+
+	if ( rmouseEvent.test( name ) ) {
+		jQuery.event.fixHooks[ name ] = jQuery.event.mouseHooks;
+	}
+});
+/*!
+ * Sizzle CSS Selector Engine
+ * Copyright 2012 jQuery Foundation and other contributors
+ * Released under the MIT license
+ * http://sizzlejs.com/
+ */
+(function( window, undefined ) {
+
+var cachedruns,
+	assertGetIdNotName,
+	Expr,
+	getText,
+	isXML,
+	contains,
+	compile,
+	sortOrder,
+	hasDuplicate,
+	outermostContext,
+
+	baseHasDuplicate = true,
+	strundefined = "undefined",
+
+	expando = ( "sizcache" + Math.random() ).replace( ".", "" ),
+
+	Token = String,
+	document = window.document,
+	docElem = document.documentElement,
+	dirruns = 0,
+	done = 0,
+	pop = [].pop,
+	push = [].push,
+	slice = [].slice,
+	// Use a stripped-down indexOf if a native one is unavailable
+	indexOf = [].indexOf || function( elem ) {
+		var i = 0,
+			len = this.length;
+		for ( ; i < len; i++ ) {
+			if ( this[i] === elem ) {
+				return i;
+			}
+		}
+		return -1;
+	},
+
+	// Augment a function for special use by Sizzle
+	markFunction = function( fn, value ) {
+		fn[ expando ] = value == null || value;
+		return fn;
+	},
+
+	createCache = function() {
+		var cache = {},
+			keys = [];
+
+		return markFunction(function( key, value ) {
+			// Only keep the most recent entries
+			if ( keys.push( key ) > Expr.cacheLength ) {
+				delete cache[ keys.shift() ];
+			}
+
+			return (cache[ key ] = value);
+		}, cache );
+	},
+
+	classCache = createCache(),
+	tokenCache = createCache(),
+	compilerCache = createCache(),
+
+	// Regex
+
+	// Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace
+	whitespace = "[\\x20\\t\\r\\n\\f]",
+	// http://www.w3.org/TR/css3-syntax/#characters
+	characterEncoding = "(?:\\\\.|[-\\w]|[^\\x00-\\xa0])+",
+
+	// Loosely modeled on CSS identifier characters
+	// An unquoted value should be a CSS identifier (http://www.w3.org/TR/css3-selectors/#attribute-selectors)
+	// Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
+	identifier = characterEncoding.replace( "w", "w#" ),
+
+	// Acceptable operators http://www.w3.org/TR/selectors/#attribute-selectors
+	operators = "([*^$|!~]?=)",
+	attributes = "\\[" + whitespace + "*(" + characterEncoding + ")" + whitespace +
+		"*(?:" + operators + whitespace + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + identifier + ")|)|)" + whitespace + "*\\]",
+
+	// Prefer arguments not in parens/brackets,
+	//   then attribute selectors and non-pseudos (denoted by :),
+	//   then anything else
+	// These preferences are here to reduce the number of selectors
+	//   needing tokenize in the PSEUDO preFilter
+	pseudos = ":(" + characterEncoding + ")(?:\\((?:(['\"])((?:\\\\.|[^\\\\])*?)\\2|([^()[\\]]*|(?:(?:" + attributes + ")|[^:]|\\\\.)*|.*))\\)|)",
+
+	// For matchExpr.POS and matchExpr.needsContext
+	pos = ":(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace +
+		"*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)",
+
+	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
+	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
+
+	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
+	rcombinators = new RegExp( "^" + whitespace + "*([\\x20\\t\\r\\n\\f>+~])" + whitespace + "*" ),
+	rpseudo = new RegExp( pseudos ),
+
+	// Easily-parseable/retrievable ID or TAG or CLASS selectors
+	rquickExpr = /^(?:#([\w\-]+)|(\w+)|\.([\w\-]+))$/,
+
+	rnot = /^:not/,
+	rsibling = /[\x20\t\r\n\f]*[+~]/,
+	rendsWithNot = /:not\($/,
+
+	rheader = /h\d/i,
+	rinputs = /input|select|textarea|button/i,
+
+	rbackslash = /\\(?!\\)/g,
+
+	matchExpr = {
+		"ID": new RegExp( "^#(" + characterEncoding + ")" ),
+		"CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ),
+		"NAME": new RegExp( "^\\[name=['\"]?(" + characterEncoding + ")['\"]?\\]" ),
+		"TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ),
+		"ATTR": new RegExp( "^" + attributes ),
+		"PSEUDO": new RegExp( "^" + pseudos ),
+		"POS": new RegExp( pos, "i" ),
+		"CHILD": new RegExp( "^:(only|nth|first|last)-child(?:\\(" + whitespace +
+			"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
+			"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
+		// For use in libraries implementing .is()
+		"needsContext": new RegExp( "^" + whitespace + "*[>+~]|" + pos, "i" )
+	},
+
+	// Support
+
+	// Used for testing something on an element
+	assert = function( fn ) {
+		var div = document.createElement("div");
+
+		try {
+			return fn( div );
+		} catch (e) {
+			return false;
+		} finally {
+			// release memory in IE
+			div = null;
+		}
+	},
+
+	// Check if getElementsByTagName("*") returns only elements
+	assertTagNameNoComments = assert(function( div ) {
+		div.appendChild( document.createComment("") );
+		return !div.getElementsByTagName("*").length;
+	}),
+
+	// Check if getAttribute returns normalized href attributes
+	assertHrefNotNormalized = assert(function( div ) {
+		div.innerHTML = "<a href='#'></a>";
+		return div.firstChild && typeof div.firstChild.getAttribute !== strundefined &&
+			div.firstChild.getAttribute("href") === "#";
+	}),
+
+	// Check if attributes should be retrieved by attribute nodes
+	assertAttributes = assert(function( div ) {
+		div.innerHTML = "<select></select>";
+		var type = typeof div.lastChild.getAttribute("multiple");
+		// IE8 returns a string for some attributes even when not present
+		return type !== "boolean" && type !== "string";
+	}),
+
+	// Check if getElementsByClassName can be trusted
+	assertUsableClassName = assert(function( div ) {
+		// Opera can't find a second classname (in 9.6)
+		div.innerHTML = "<div class='hidden e'></div><div class='hidden'></div>";
+		if ( !div.getElementsByClassName || !div.getElementsByClassName("e").length ) {
+			return false;
+		}
+
+		// Safari 3.2 caches class attributes and doesn't catch changes
+		div.lastChild.className = "e";
+		return div.getElementsByClassName("e").length === 2;
+	}),
+
+	// Check if getElementById returns elements by name
+	// Check if getElementsByName privileges form controls or returns elements by ID
+	assertUsableName = assert(function( div ) {
+		// Inject content
+		div.id = expando + 0;
+		div.innerHTML = "<a name='" + expando + "'></a><div name='" + expando + "'></div>";
+		docElem.insertBefore( div, docElem.firstChild );
+
+		// Test
+		var pass = document.getElementsByName &&
+			// buggy browsers will return fewer than the correct 2
+			document.getElementsByName( expando ).length === 2 +
+			// buggy browsers will return more than the correct 0
+			document.getElementsByName( expando + 0 ).length;
+		assertGetIdNotName = !document.getElementById( expando );
+
+		// Cleanup
+		docElem.removeChild( div );
+
+		return pass;
+	});
+
+// If slice is not available, provide a backup
+try {
+	slice.call( docElem.childNodes, 0 )[0].nodeType;
+} catch ( e ) {
+	slice = function( i ) {
+		var elem,
+			results = [];
+		for ( ; (elem = this[i]); i++ ) {
+			results.push( elem );
+		}
+		return results;
+	};
+}
+
+function Sizzle( selector, context, results, seed ) {
+	results = results || [];
+	context = context || document;
+	var match, elem, xml, m,
+		nodeType = context.nodeType;
+
+	if ( !selector || typeof selector !== "string" ) {
+		return results;
+	}
+
+	if ( nodeType !== 1 && nodeType !== 9 ) {
+		return [];
+	}
+
+	xml = isXML( context );
+
+	if ( !xml && !seed ) {
+		if ( (match = rquickExpr.exec( selector )) ) {
+			// Speed-up: Sizzle("#ID")
+			if ( (m = match[1]) ) {
+				if ( nodeType === 9 ) {
+					elem = context.getElementById( m );
+					// Check parentNode to catch when Blackberry 4.6 returns
+					// nodes that are no longer in the document #6963
+					if ( elem && elem.parentNode ) {
+						// Handle the case where IE, Opera, and Webkit return items
+						// by name instead of ID
+						if ( elem.id === m ) {
+							results.push( elem );
+							return results;
+						}
+					} else {
+						return results;
+					}
+				} else {
+					// Context is not a document
+					if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) &&
+						contains( context, elem ) && elem.id === m ) {
+						results.push( elem );
+						return results;
+					}
+				}
+
+			// Speed-up: Sizzle("TAG")
+			} else if ( match[2] ) {
+				push.apply( results, slice.call(context.getElementsByTagName( selector ), 0) );
+				return results;
+
+			// Speed-up: Sizzle(".CLASS")
+			} else if ( (m = match[3]) && assertUsableClassName && context.getElementsByClassName ) {
+				push.apply( results, slice.call(context.getElementsByClassName( m ), 0) );
+				return results;
+			}
+		}
+	}
+
+	// All others
+	return select( selector.replace( rtrim, "$1" ), context, results, seed, xml );
+}
+
+Sizzle.matches = function( expr, elements ) {
+	return Sizzle( expr, null, null, elements );
+};
+
+Sizzle.matchesSelector = function( elem, expr ) {
+	return Sizzle( expr, null, null, [ elem ] ).length > 0;
+};
+
+// Returns a function to use in pseudos for input types
+function createInputPseudo( type ) {
+	return function( elem ) {
+		var name = elem.nodeName.toLowerCase();
+		return name === "input" && elem.type === type;
+	};
+}
+
+// Returns a function to use in pseudos for buttons
+function createButtonPseudo( type ) {
+	return function( elem ) {
+		var name = elem.nodeName.toLowerCase();
+		return (name === "input" || name === "button") && elem.type === type;
+	};
+}
+
+// Returns a function to use in pseudos for positionals
+function createPositionalPseudo( fn ) {
+	return markFunction(function( argument ) {
+		argument = +argument;
+		return markFunction(function( seed, matches ) {
+			var j,
+				matchIndexes = fn( [], seed.length, argument ),
+				i = matchIndexes.length;
+
+			// Match elements found at the specified indexes
+			while ( i-- ) {
+				if ( seed[ (j = matchIndexes[i]) ] ) {
+					seed[j] = !(matches[j] = seed[j]);
+				}
+			}
+		});
+	});
+}
+
+/**
+ * Utility function for retrieving the text value of an array of DOM nodes
+ * @param {Array|Element} elem
+ */
+getText = Sizzle.getText = function( elem ) {
+	var node,
+		ret = "",
+		i = 0,
+		nodeType = elem.nodeType;
+
+	if ( nodeType ) {
+		if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
+			// Use textContent for elements
+			// innerText usage removed for consistency of new lines (see #11153)
+			if ( typeof elem.textContent === "string" ) {
+				return elem.textContent;
+			} else {
+				// Traverse its children
+				for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
+					ret += getText( elem );
+				}
+			}
+		} else if ( nodeType === 3 || nodeType === 4 ) {
+			return elem.nodeValue;
+		}
+		// Do not include comment or processing instruction nodes
+	} else {
+
+		// If no nodeType, this is expected to be an array
+		for ( ; (node = elem[i]); i++ ) {
+			// Do not traverse comment nodes
+			ret += getText( node );
+		}
+	}
+	return ret;
+};
+
+isXML = Sizzle.isXML = function( elem ) {
+	// documentElement is verified for cases where it doesn't yet exist
+	// (such as loading iframes in IE - #4833)
+	var documentElement = elem && (elem.ownerDocument || elem).documentElement;
+	return documentElement ? documentElement.nodeName !== "HTML" : false;
+};
+
+// Element contains another
+contains = Sizzle.contains = docElem.contains ?
+	function( a, b ) {
+		var adown = a.nodeType === 9 ? a.documentElement : a,
+			bup = b && b.parentNode;
+		return a === bup || !!( bup && bup.nodeType === 1 && adown.contains && adown.contains(bup) );
+	} :
+	docElem.compareDocumentPosition ?
+	function( a, b ) {
+		return b && !!( a.compareDocumentPosition( b ) & 16 );
+	} :
+	function( a, b ) {
+		while ( (b = b.parentNode) ) {
+			if ( b === a ) {
+				return true;
+			}
+		}
+		return false;
+	};
+
+Sizzle.attr = function( elem, name ) {
+	var val,
+		xml = isXML( elem );
+
+	if ( !xml ) {
+		name = name.toLowerCase();
+	}
+	if ( (val = Expr.attrHandle[ name ]) ) {
+		return val( elem );
+	}
+	if ( xml || assertAttributes ) {
+		return elem.getAttribute( name );
+	}
+	val = elem.getAttributeNode( name );
+	return val ?
+		typeof elem[ name ] === "boolean" ?
+			elem[ name ] ? name : null :
+			val.specified ? val.value : null :
+		null;
+};
+
+Expr = Sizzle.selectors = {
+
+	// Can be adjusted by the user
+	cacheLength: 50,
+
+	createPseudo: markFunction,
+
+	match: matchExpr,
+
+	// IE6/7 return a modified href
+	attrHandle: assertHrefNotNormalized ?
+		{} :
+		{
+			"href": function( elem ) {
+				return elem.getAttribute( "href", 2 );
+			},
+			"type": function( elem ) {
+				return elem.getAttribute("type");
+			}
+		},
+
+	find: {
+		"ID": assertGetIdNotName ?
+			function( id, context, xml ) {
+				if ( typeof context.getElementById !== strundefined && !xml ) {
+					var m = context.getElementById( id );
+					// Check parentNode to catch when Blackberry 4.6 returns
+					// nodes that are no longer in the document #6963
+					return m && m.parentNode ? [m] : [];
+				}
+			} :
+			function( id, context, xml ) {
+				if ( typeof context.getElementById !== strundefined && !xml ) {
+					var m = context.getElementById( id );
+
+					return m ?
+						m.id === id || typeof m.getAttributeNode !== strundefined && m.getAttributeNode("id").value === id ?
+							[m] :
+							undefined :
+						[];
+				}
+			},
+
+		"TAG": assertTagNameNoComments ?
+			function( tag, context ) {
+				if ( typeof context.getElementsByTagName !== strundefined ) {
+					return context.getElementsByTagName( tag );
+				}
+			} :
+			function( tag, context ) {
+				var results = context.getElementsByTagName( tag );
+
+				// Filter out possible comments
+				if ( tag === "*" ) {
+					var elem,
+						tmp = [],
+						i = 0;
+
+					for ( ; (elem = results[i]); i++ ) {
+						if ( elem.nodeType === 1 ) {
+							tmp.push( elem );
+						}
+					}
+
+					return tmp;
+				}
+				return results;
+			},
+
+		"NAME": assertUsableName && function( tag, context ) {
+			if ( typeof context.getElementsByName !== strundefined ) {
+				return context.getElementsByName( name );
+			}
+		},
+
+		"CLASS": assertUsableClassName && function( className, context, xml ) {
+			if ( typeof context.getElementsByClassName !== strundefined && !xml ) {
+				return context.getElementsByClassName( className );
+			}
+		}
+	},
+
+	relative: {
+		">": { dir: "parentNode", first: true },
+		" ": { dir: "parentNode" },
+		"+": { dir: "previousSibling", first: true },
+		"~": { dir: "previousSibling" }
+	},
+
+	preFilter: {
+		"ATTR": function( match ) {
+			match[1] = match[1].replace( rbackslash, "" );
+
+			// Move the given value to match[3] whether quoted or unquoted
+			match[3] = ( match[4] || match[5] || "" ).replace( rbackslash, "" );
+
+			if ( match[2] === "~=" ) {
+				match[3] = " " + match[3] + " ";
+			}
+
+			return match.slice( 0, 4 );
+		},
+
+		"CHILD": function( match ) {
+			/* matches from matchExpr["CHILD"]
+				1 type (only|nth|...)
+				2 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
+				3 xn-component of xn+y argument ([+-]?\d*n|)
+				4 sign of xn-component
+				5 x of xn-component
+				6 sign of y-component
+				7 y of y-component
+			*/
+			match[1] = match[1].toLowerCase();
+
+			if ( match[1] === "nth" ) {
+				// nth-child requires argument
+				if ( !match[2] ) {
+					Sizzle.error( match[0] );
+				}
+
+				// numeric x and y parameters for Expr.filter.CHILD
+				// remember that false/true cast respectively to 0/1
+				match[3] = +( match[3] ? match[4] + (match[5] || 1) : 2 * ( match[2] === "even" || match[2] === "odd" ) );
+				match[4] = +( ( match[6] + match[7] ) || match[2] === "odd" );
+
+			// other types prohibit arguments
+			} else if ( match[2] ) {
+				Sizzle.error( match[0] );
+			}
+
+			return match;
+		},
+
+		"PSEUDO": function( match ) {
+			var unquoted, excess;
+			if ( matchExpr["CHILD"].test( match[0] ) ) {
+				return null;
+			}
+
+			if ( match[3] ) {
+				match[2] = match[3];
+			} else if ( (unquoted = match[4]) ) {
+				// Only check arguments that contain a pseudo
+				if ( rpseudo.test(unquoted) &&
+					// Get excess from tokenize (recursively)
+					(excess = tokenize( unquoted, true )) &&
+					// advance to the next closing parenthesis
+					(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
+
+					// excess is a negative index
+					unquoted = unquoted.slice( 0, excess );
+					match[0] = match[0].slice( 0, excess );
+				}
+				match[2] = unquoted;
+			}
+
+			// Return only captures needed by the pseudo filter method (type and argument)
+			return match.slice( 0, 3 );
+		}
+	},
+
+	filter: {
+		"ID": assertGetIdNotName ?
+			function( id ) {
+				id = id.replace( rbackslash, "" );
+				return function( elem ) {
+					return elem.getAttribute("id") === id;
+				};
+			} :
+			function( id ) {
+				id = id.replace( rbackslash, "" );
+				return function( elem ) {
+					var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id");
+					return node && node.value === id;
+				};
+			},
+
+		"TAG": function( nodeName ) {
+			if ( nodeName === "*" ) {
+				return function() { return true; };
+			}
+			nodeName = nodeName.replace( rbackslash, "" ).toLowerCase();
+
+			return function( elem ) {
+				return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
+			};
+		},
+
+		"CLASS": function( className ) {
+			var pattern = classCache[ expando ][ className ];
+			if ( !pattern ) {
+				pattern = classCache( className, new RegExp("(^|" + whitespace + ")" + className + "(" + whitespace + "|$)") );
+			}
+			return function( elem ) {
+				return pattern.test( elem.className || (typeof elem.getAttribute !== strundefined && elem.getAttribute("class")) || "" );
+			};
+		},
+
+		"ATTR": function( name, operator, check ) {
+			return function( elem, context ) {
+				var result = Sizzle.attr( elem, name );
+
+				if ( result == null ) {
+					return operator === "!=";
+				}
+				if ( !operator ) {
+					return true;
+				}
+
+				result += "";
+
+				return operator === "=" ? result === check :
+					operator === "!=" ? result !== check :
+					operator === "^=" ? check && result.indexOf( check ) === 0 :
+					operator === "*=" ? check && result.indexOf( check ) > -1 :
+					operator === "$=" ? check && result.substr( result.length - check.length ) === check :
+					operator === "~=" ? ( " " + result + " " ).indexOf( check ) > -1 :
+					operator === "|=" ? result === check || result.substr( 0, check.length + 1 ) === check + "-" :
+					false;
+			};
+		},
+
+		"CHILD": function( type, argument, first, last ) {
+
+			if ( type === "nth" ) {
+				return function( elem ) {
+					var node, diff,
+						parent = elem.parentNode;
+
+					if ( first === 1 && last === 0 ) {
+						return true;
+					}
+
+					if ( parent ) {
+						diff = 0;
+						for ( node = parent.firstChild; node; node = node.nextSibling ) {
+							if ( node.nodeType === 1 ) {
+								diff++;
+								if ( elem === node ) {
+									break;
+								}
+							}
+						}
+					}
+
+					// Incorporate the offset (or cast to NaN), then check against cycle size
+					diff -= last;
+					return diff === first || ( diff % first === 0 && diff / first >= 0 );
+				};
+			}
+
+			return function( elem ) {
+				var node = elem;
+
+				switch ( type ) {
+					case "only":
+					case "first":
+						while ( (node = node.previousSibling) ) {
+							if ( node.nodeType === 1 ) {
+								return false;
+							}
+						}
+
+						if ( type === "first" ) {
+							return true;
+						}
+
+						node = elem;
+
+						/* falls through */
+					case "last":
+						while ( (node = node.nextSibling) ) {
+							if ( node.nodeType === 1 ) {
+								return false;
+							}
+						}
+
+						return true;
+				}
+			};
+		},
+
+		"PSEUDO": function( pseudo, argument ) {
+			// pseudo-class names are case-insensitive
+			// http://www.w3.org/TR/selectors/#pseudo-classes
+			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
+			// Remember that setFilters inherits from pseudos
+			var args,
+				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
+					Sizzle.error( "unsupported pseudo: " + pseudo );
+
+			// The user may use createPseudo to indicate that
+			// arguments are needed to create the filter function
+			// just as Sizzle does
+			if ( fn[ expando ] ) {
+				return fn( argument );
+			}
+
+			// But maintain support for old signatures
+			if ( fn.length > 1 ) {
+				args = [ pseudo, pseudo, "", argument ];
+				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
+					markFunction(function( seed, matches ) {
+						var idx,
+							matched = fn( seed, argument ),
+							i = matched.length;
+						while ( i-- ) {
+							idx = indexOf.call( seed, matched[i] );
+							seed[ idx ] = !( matches[ idx ] = matched[i] );
+						}
+					}) :
+					function( elem ) {
+						return fn( elem, 0, args );
+					};
+			}
+
+			return fn;
+		}
+	},
+
+	pseudos: {
+		"not": markFunction(function( selector ) {
+			// Trim the selector passed to compile
+			// to avoid treating leading and trailing
+			// spaces as combinators
+			var input = [],
+				results = [],
+				matcher = compile( selector.replace( rtrim, "$1" ) );
+
+			return matcher[ expando ] ?
+				markFunction(function( seed, matches, context, xml ) {
+					var elem,
+						unmatched = matcher( seed, null, xml, [] ),
+						i = seed.length;
+
+					// Match elements unmatched by `matcher`
+					while ( i-- ) {
+						if ( (elem = unmatched[i]) ) {
+							seed[i] = !(matches[i] = elem);
+						}
+					}
+				}) :
+				function( elem, context, xml ) {
+					input[0] = elem;
+					matcher( input, null, xml, results );
+					return !results.pop();
+				};
+		}),
+
+		"has": markFunction(function( selector ) {
+			return function( elem ) {
+				return Sizzle( selector, elem ).length > 0;
+			};
+		}),
+
+		"contains": markFunction(function( text ) {
+			return function( elem ) {
+				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
+			};
+		}),
+
+		"enabled": function( elem ) {
+			return elem.disabled === false;
+		},
+
+		"disabled": function( elem ) {
+			return elem.disabled === true;
+		},
+
+		"checked": function( elem ) {
+			// In CSS3, :checked should return both checked and selected elements
+			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
+			var nodeName = elem.nodeName.toLowerCase();
+			return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
+		},
+
+		"selected": function( elem ) {
+			// Accessing this property makes selected-by-default
+			// options in Safari work properly
+			if ( elem.parentNode ) {
+				elem.parentNode.selectedIndex;
+			}
+
+			return elem.selected === true;
+		},
+
+		"parent": function( elem ) {
+			return !Expr.pseudos["empty"]( elem );
+		},
+
+		"empty": function( elem ) {
+			// http://www.w3.org/TR/selectors/#empty-pseudo
+			// :empty is only affected by element nodes and content nodes(including text(3), cdata(4)),
+			//   not comment, processing instructions, or others
+			// Thanks to Diego Perini for the nodeName shortcut
+			//   Greater than "@" means alpha characters (specifically not starting with "#" or "?")
+			var nodeType;
+			elem = elem.firstChild;
+			while ( elem ) {
+				if ( elem.nodeName > "@" || (nodeType = elem.nodeType) === 3 || nodeType === 4 ) {
+					return false;
+				}
+				elem = elem.nextSibling;
+			}
+			return true;
+		},
+
+		"header": function( elem ) {
+			return rheader.test( elem.nodeName );
+		},
+
+		"text": function( elem ) {
+			var type, attr;
+			// IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
+			// use getAttribute instead to test this case
+			return elem.nodeName.toLowerCase() === "input" &&
+				(type = elem.type) === "text" &&
+				( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === type );
+		},
+
+		// Input types
+		"radio": createInputPseudo("radio"),
+		"checkbox": createInputPseudo("checkbox"),
+		"file": createInputPseudo("file"),
+		"password": createInputPseudo("password"),
+		"image": createInputPseudo("image"),
+
+		"submit": createButtonPseudo("submit"),
+		"reset": createButtonPseudo("reset"),
+
+		"button": function( elem ) {
+			var name = elem.nodeName.toLowerCase();
+			return name === "input" && elem.type === "button" || name === "button";
+		},
+
+		"input": function( elem ) {
+			return rinputs.test( elem.nodeName );
+		},
+
+		"focus": function( elem ) {
+			var doc = elem.ownerDocument;
+			return elem === doc.activeElement && (!doc.hasFocus || doc.hasFocus()) && !!(elem.type || elem.href);
+		},
+
+		"active": function( elem ) {
+			return elem === elem.ownerDocument.activeElement;
+		},
+
+		// Positional types
+		"first": createPositionalPseudo(function( matchIndexes, length, argument ) {
+			return [ 0 ];
+		}),
+
+		"last": createPositionalPseudo(function( matchIndexes, length, argument ) {
+			return [ length - 1 ];
+		}),
+
+		"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
+			return [ argument < 0 ? argument + length : argument ];
+		}),
+
+		"even": createPositionalPseudo(function( matchIndexes, length, argument ) {
+			for ( var i = 0; i < length; i += 2 ) {
+				matchIndexes.push( i );
+			}
+			return matchIndexes;
+		}),
+
+		"odd": createPositionalPseudo(function( matchIndexes, length, argument ) {
+			for ( var i = 1; i < length; i += 2 ) {
+				matchIndexes.push( i );
+			}
+			return matchIndexes;
+		}),
+
+		"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
+			for ( var i = argument < 0 ? argument + length : argument; --i >= 0; ) {
+				matchIndexes.push( i );
+			}
+			return matchIndexes;
+		}),
+
+		"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
+			for ( var i = argument < 0 ? argument + length : argument; ++i < length; ) {
+				matchIndexes.push( i );
+			}
+			return matchIndexes;
+		})
+	}
+};
+
+function siblingCheck( a, b, ret ) {
+	if ( a === b ) {
+		return ret;
+	}
+
+	var cur = a.nextSibling;
+
+	while ( cur ) {
+		if ( cur === b ) {
+			return -1;
+		}
+
+		cur = cur.nextSibling;
+	}
+
+	return 1;
+}
+
+sortOrder = docElem.compareDocumentPosition ?
+	function( a, b ) {
+		if ( a === b ) {
+			hasDuplicate = true;
+			return 0;
+		}
+
+		return ( !a.compareDocumentPosition || !b.compareDocumentPosition ?
+			a.compareDocumentPosition :
+			a.compareDocumentPosition(b) & 4
+		) ? -1 : 1;
+	} :
+	function( a, b ) {
+		// The nodes are identical, we can exit early
+		if ( a === b ) {
+			hasDuplicate = true;
+			return 0;
+
+		// Fallback to using sourceIndex (in IE) if it's available on both nodes
+		} else if ( a.sourceIndex && b.sourceIndex ) {
+			return a.sourceIndex - b.sourceIndex;
+		}
+
+		var al, bl,
+			ap = [],
+			bp = [],
+			aup = a.parentNode,
+			bup = b.parentNode,
+			cur = aup;
+
+		// If the nodes are siblings (or identical) we can do a quick check
+		if ( aup === bup ) {
+			return siblingCheck( a, b );
+
+		// If no parents were found then the nodes are disconnected
+		} else if ( !aup ) {
+			return -1;
+
+		} else if ( !bup ) {
+			return 1;
+		}
+
+		// Otherwise they're somewhere else in the tree so we need
+		// to build up a full list of the parentNodes for comparison
+		while ( cur ) {
+			ap.unshift( cur );
+			cur = cur.parentNode;
+		}
+
+		cur = bup;
+
+		while ( cur ) {
+			bp.unshift( cur );
+			cur = cur.parentNode;
+		}
+
+		al = ap.length;
+		bl = bp.length;
+
+		// Start walking down the tree looking for a discrepancy
+		for ( var i = 0; i < al && i < bl; i++ ) {
+			if ( ap[i] !== bp[i] ) {
+				return siblingCheck( ap[i], bp[i] );
+			}
+		}
+
+		// We ended someplace up the tree so do a sibling check
+		return i === al ?
+			siblingCheck( a, bp[i], -1 ) :
+			siblingCheck( ap[i], b, 1 );
+	};
+
+// Always assume the presence of duplicates if sort doesn't
+// pass them to our comparison function (as in Google Chrome).
+[0, 0].sort( sortOrder );
+baseHasDuplicate = !hasDuplicate;
+
+// Document sorting and removing duplicates
+Sizzle.uniqueSort = function( results ) {
+	var elem,
+		i = 1;
+
+	hasDuplicate = baseHasDuplicate;
+	results.sort( sortOrder );
+
+	if ( hasDuplicate ) {
+		for ( ; (elem = results[i]); i++ ) {
+			if ( elem === results[ i - 1 ] ) {
+				results.splice( i--, 1 );
+			}
+		}
+	}
+
+	return results;
+};
+
+Sizzle.error = function( msg ) {
+	throw new Error( "Syntax error, unrecognized expression: " + msg );
+};
+
+function tokenize( selector, parseOnly ) {
+	var matched, match, tokens, type, soFar, groups, preFilters,
+		cached = tokenCache[ expando ][ selector ];
+
+	if ( cached ) {
+		return parseOnly ? 0 : cached.slice( 0 );
+	}
+
+	soFar = selector;
+	groups = [];
+	preFilters = Expr.preFilter;
+
+	while ( soFar ) {
+
+		// Comma and first run
+		if ( !matched || (match = rcomma.exec( soFar )) ) {
+			if ( match ) {
+				soFar = soFar.slice( match[0].length );
+			}
+			groups.push( tokens = [] );
+		}
+
+		matched = false;
+
+		// Combinators
+		if ( (match = rcombinators.exec( soFar )) ) {
+			tokens.push( matched = new Token( match.shift() ) );
+			soFar = soFar.slice( matched.length );
+
+			// Cast descendant combinators to space
+			matched.type = match[0].replace( rtrim, " " );
+		}
+
+		// Filters
+		for ( type in Expr.filter ) {
+			if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
+				// The last two arguments here are (context, xml) for backCompat
+				(match = preFilters[ type ]( match, document, true ))) ) {
+
+				tokens.push( matched = new Token( match.shift() ) );
+				soFar = soFar.slice( matched.length );
+				matched.type = type;
+				matched.matches = match;
+			}
+		}
+
+		if ( !matched ) {
+			break;
+		}
+	}
+
+	// Return the length of the invalid excess
+	// if we're just parsing
+	// Otherwise, throw an error or return tokens
+	return parseOnly ?
+		soFar.length :
+		soFar ?
+			Sizzle.error( selector ) :
+			// Cache the tokens
+			tokenCache( selector, groups ).slice( 0 );
+}
+
+function addCombinator( matcher, combinator, base ) {
+	var dir = combinator.dir,
+		checkNonElements = base && combinator.dir === "parentNode",
+		doneName = done++;
+
+	return combinator.first ?
+		// Check against closest ancestor/preceding element
+		function( elem, context, xml ) {
+			while ( (elem = elem[ dir ]) ) {
+				if ( checkNonElements || elem.nodeType === 1  ) {
+					return matcher( elem, context, xml );
+				}
+			}
+		} :
+
+		// Check against all ancestor/preceding elements
+		function( elem, context, xml ) {
+			// We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
+			if ( !xml ) {
+				var cache,
+					dirkey = dirruns + " " + doneName + " ",
+					cachedkey = dirkey + cachedruns;
+				while ( (elem = elem[ dir ]) ) {
+					if ( checkNonElements || elem.nodeType === 1 ) {
+						if ( (cache = elem[ expando ]) === cachedkey ) {
+							return elem.sizset;
+						} else if ( typeof cache === "string" && cache.indexOf(dirkey) === 0 ) {
+							if ( elem.sizset ) {
+								return elem;
+							}
+						} else {
+							elem[ expando ] = cachedkey;
+							if ( matcher( elem, context, xml ) ) {
+								elem.sizset = true;
+								return elem;
+							}
+							elem.sizset = false;
+						}
+					}
+				}
+			} else {
+				while ( (elem = elem[ dir ]) ) {
+					if ( checkNonElements || elem.nodeType === 1 ) {
+						if ( matcher( elem, context, xml ) ) {
+							return elem;
+						}
+					}
+				}
+			}
+		};
+}
+
+function elementMatcher( matchers ) {
+	return matchers.length > 1 ?
+		function( elem, context, xml ) {
+			var i = matchers.length;
+			while ( i-- ) {
+				if ( !matchers[i]( elem, context, xml ) ) {
+					return false;
+				}
+			}
+			return true;
+		} :
+		matchers[0];
+}
+
+function condense( unmatched, map, filter, context, xml ) {
+	var elem,
+		newUnmatched = [],
+		i = 0,
+		len = unmatched.length,
+		mapped = map != null;
+
+	for ( ; i < len; i++ ) {
+		if ( (elem = unmatched[i]) ) {
+			if ( !filter || filter( elem, context, xml ) ) {
+				newUnmatched.push( elem );
+				if ( mapped ) {
+					map.push( i );
+				}
+			}
+		}
+	}
+
+	return newUnmatched;
+}
+
+function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
+	if ( postFilter && !postFilter[ expando ] ) {
+		postFilter = setMatcher( postFilter );
+	}
+	if ( postFinder && !postFinder[ expando ] ) {
+		postFinder = setMatcher( postFinder, postSelector );
+	}
+	return markFunction(function( seed, results, context, xml ) {
+		// Positional selectors apply to seed elements, so it is invalid to follow them with relative ones
+		if ( seed && postFinder ) {
+			return;
+		}
+
+		var i, elem, postFilterIn,
+			preMap = [],
+			postMap = [],
+			preexisting = results.length,
+
+			// Get initial elements from seed or context
+			elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [], seed ),
+
+			// Prefilter to get matcher input, preserving a map for seed-results synchronization
+			matcherIn = preFilter && ( seed || !selector ) ?
+				condense( elems, preMap, preFilter, context, xml ) :
+				elems,
+
+			matcherOut = matcher ?
+				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
+				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
+
+					// ...intermediate processing is necessary
+					[] :
+
+					// ...otherwise use results directly
+					results :
+				matcherIn;
+
+		// Find primary matches
+		if ( matcher ) {
+			matcher( matcherIn, matcherOut, context, xml );
+		}
+
+		// Apply postFilter
+		if ( postFilter ) {
+			postFilterIn = condense( matcherOut, postMap );
+			postFilter( postFilterIn, [], context, xml );
+
+			// Un-match failing elements by moving them back to matcherIn
+			i = postFilterIn.length;
+			while ( i-- ) {
+				if ( (elem = postFilterIn[i]) ) {
+					matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
+				}
+			}
+		}
+
+		// Keep seed and results synchronized
+		if ( seed ) {
+			// Ignore postFinder because it can't coexist with seed
+			i = preFilter && matcherOut.length;
+			while ( i-- ) {
+				if ( (elem = matcherOut[i]) ) {
+					seed[ preMap[i] ] = !(results[ preMap[i] ] = elem);
+				}
+			}
+		} else {
+			matcherOut = condense(
+				matcherOut === results ?
+					matcherOut.splice( preexisting, matcherOut.length ) :
+					matcherOut
+			);
+			if ( postFinder ) {
+				postFinder( null, results, matcherOut, xml );
+			} else {
+				push.apply( results, matcherOut );
+			}
+		}
+	});
+}
+
+function matcherFromTokens( tokens ) {
+	var checkContext, matcher, j,
+		len = tokens.length,
+		leadingRelative = Expr.relative[ tokens[0].type ],
+		implicitRelative = leadingRelative || Expr.relative[" "],
+		i = leadingRelative ? 1 : 0,
+
+		// The foundational matcher ensures that elements are reachable from top-level context(s)
+		matchContext = addCombinator( function( elem ) {
+			return elem === checkContext;
+		}, implicitRelative, true ),
+		matchAnyContext = addCombinator( function( elem ) {
+			return indexOf.call( checkContext, elem ) > -1;
+		}, implicitRelative, true ),
+		matchers = [ function( elem, context, xml ) {
+			return ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
+				(checkContext = context).nodeType ?
+					matchContext( elem, context, xml ) :
+					matchAnyContext( elem, context, xml ) );
+		} ];
+
+	for ( ; i < len; i++ ) {
+		if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
+			matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];
+		} else {
+			// The concatenated values are (context, xml) for backCompat
+			matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
+
+			// Return special upon seeing a positional matcher
+			if ( matcher[ expando ] ) {
+				// Find the next relative operator (if any) for proper handling
+				j = ++i;
+				for ( ; j < len; j++ ) {
+					if ( Expr.relative[ tokens[j].type ] ) {
+						break;
+					}
+				}
+				return setMatcher(
+					i > 1 && elementMatcher( matchers ),
+					i > 1 && tokens.slice( 0, i - 1 ).join("").replace( rtrim, "$1" ),
+					matcher,
+					i < j && matcherFromTokens( tokens.slice( i, j ) ),
+					j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
+					j < len && tokens.join("")
+				);
+			}
+			matchers.push( matcher );
+		}
+	}
+
+	return elementMatcher( matchers );
+}
+
+function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
+	var bySet = setMatchers.length > 0,
+		byElement = elementMatchers.length > 0,
+		superMatcher = function( seed, context, xml, results, expandContext ) {
+			var elem, j, matcher,
+				setMatched = [],
+				matchedCount = 0,
+				i = "0",
+				unmatched = seed && [],
+				outermost = expandContext != null,
+				contextBackup = outermostContext,
+				// We must always have either seed elements or context
+				elems = seed || byElement && Expr.find["TAG"]( "*", expandContext && context.parentNode || context ),
+				// Nested matchers should use non-integer dirruns
+				dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.E);
+
+			if ( outermost ) {
+				outermostContext = context !== document && context;
+				cachedruns = superMatcher.el;
+			}
+
+			// Add elements passing elementMatchers directly to results
+			for ( ; (elem = elems[i]) != null; i++ ) {
+				if ( byElement && elem ) {
+					for ( j = 0; (matcher = elementMatchers[j]); j++ ) {
+						if ( matcher( elem, context, xml ) ) {
+							results.push( elem );
+							break;
+						}
+					}
+					if ( outermost ) {
+						dirruns = dirrunsUnique;
+						cachedruns = ++superMatcher.el;
+					}
+				}
+
+				// Track unmatched elements for set filters
+				if ( bySet ) {
+					// They will have gone through all possible matchers
+					if ( (elem = !matcher && elem) ) {
+						matchedCount--;
+					}
+
+					// Lengthen the array for every element, matched or not
+					if ( seed ) {
+						unmatched.push( elem );
+					}
+				}
+			}
+
+			// Apply set filters to unmatched elements
+			matchedCount += i;
+			if ( bySet && i !== matchedCount ) {
+				for ( j = 0; (matcher = setMatchers[j]); j++ ) {
+					matcher( unmatched, setMatched, context, xml );
+				}
+
+				if ( seed ) {
+					// Reintegrate element matches to eliminate the need for sorting
+					if ( matchedCount > 0 ) {
+						while ( i-- ) {
+							if ( !(unmatched[i] || setMatched[i]) ) {
+								setMatched[i] = pop.call( results );
+							}
+						}
+					}
+
+					// Discard index placeholder values to get only actual matches
+					setMatched = condense( setMatched );
+				}
+
+				// Add matches to results
+				push.apply( results, setMatched );
+
+				// Seedless set matches succeeding multiple successful matchers stipulate sorting
+				if ( outermost && !seed && setMatched.length > 0 &&
+					( matchedCount + setMatchers.length ) > 1 ) {
+
+					Sizzle.uniqueSort( results );
+				}
+			}
+
+			// Override manipulation of globals by nested matchers
+			if ( outermost ) {
+				dirruns = dirrunsUnique;
+				outermostContext = contextBackup;
+			}
+
+			return unmatched;
+		};
+
+	superMatcher.el = 0;
+	return bySet ?
+		markFunction( superMatcher ) :
+		superMatcher;
+}
+
+compile = Sizzle.compile = function( selector, group /* Internal Use Only */ ) {
+	var i,
+		setMatchers = [],
+		elementMatchers = [],
+		cached = compilerCache[ expando ][ selector ];
+
+	if ( !cached ) {
+		// Generate a function of recursive functions that can be used to check each element
+		if ( !group ) {
+			group = tokenize( selector );
+		}
+		i = group.length;
+		while ( i-- ) {
+			cached = matcherFromTokens( group[i] );
+			if ( cached[ expando ] ) {
+				setMatchers.push( cached );
+			} else {
+				elementMatchers.push( cached );
+			}
+		}
+
+		// Cache the compiled function
+		cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
+	}
+	return cached;
+};
+
+function multipleContexts( selector, contexts, results, seed ) {
+	var i = 0,
+		len = contexts.length;
+	for ( ; i < len; i++ ) {
+		Sizzle( selector, contexts[i], results, seed );
+	}
+	return results;
+}
+
+function select( selector, context, results, seed, xml ) {
+	var i, tokens, token, type, find,
+		match = tokenize( selector ),
+		j = match.length;
+
+	if ( !seed ) {
+		// Try to minimize operations if there is only one group
+		if ( match.length === 1 ) {
+
+			// Take a shortcut and set the context if the root selector is an ID
+			tokens = match[0] = match[0].slice( 0 );
+			if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
+					context.nodeType === 9 && !xml &&
+					Expr.relative[ tokens[1].type ] ) {
+
+				context = Expr.find["ID"]( token.matches[0].replace( rbackslash, "" ), context, xml )[0];
+				if ( !context ) {
+					return results;
+				}
+
+				selector = selector.slice( tokens.shift().length );
+			}
+
+			// Fetch a seed set for right-to-left matching
+			for ( i = matchExpr["POS"].test( selector ) ? -1 : tokens.length - 1; i >= 0; i-- ) {
+				token = tokens[i];
+
+				// Abort if we hit a combinator
+				if ( Expr.relative[ (type = token.type) ] ) {
+					break;
+				}
+				if ( (find = Expr.find[ type ]) ) {
+					// Search, expanding context for leading sibling combinators
+					if ( (seed = find(
+						token.matches[0].replace( rbackslash, "" ),
+						rsibling.test( tokens[0].type ) && context.parentNode || context,
+						xml
+					)) ) {
+
+						// If seed is empty or no tokens remain, we can return early
+						tokens.splice( i, 1 );
+						selector = seed.length && tokens.join("");
+						if ( !selector ) {
+							push.apply( results, slice.call( seed, 0 ) );
+							return results;
+						}
+
+						break;
+					}
+				}
+			}
+		}
+	}
+
+	// Compile and execute a filtering function
+	// Provide `match` to avoid retokenization if we modified the selector above
+	compile( selector, match )(
+		seed,
+		context,
+		xml,
+		results,
+		rsibling.test( selector )
+	);
+	return results;
+}
+
+if ( document.querySelectorAll ) {
+	(function() {
+		var disconnectedMatch,
+			oldSelect = select,
+			rescape = /'|\\/g,
+			rattributeQuotes = /\=[\x20\t\r\n\f]*([^'"\]]*)[\x20\t\r\n\f]*\]/g,
+
+			// qSa(:focus) reports false when true (Chrome 21),
+			// A support test would require too much code (would include document ready)
+			rbuggyQSA = [":focus"],
+
+			// matchesSelector(:focus) reports false when true (Chrome 21),
+			// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
+			// A support test would require too much code (would include document ready)
+			// just skip matchesSelector for :active
+			rbuggyMatches = [ ":active", ":focus" ],
+			matches = docElem.matchesSelector ||
+				docElem.mozMatchesSelector ||
+				docElem.webkitMatchesSelector ||
+				docElem.oMatchesSelector ||
+				docElem.msMatchesSelector;
+
+		// Build QSA regex
+		// Regex strategy adopted from Diego Perini
+		assert(function( div ) {
+			// Select is set to empty string on purpose
+			// This is to test IE's treatment of not explictly
+			// setting a boolean content attribute,
+			// since its presence should be enough
+			// http://bugs.jquery.com/ticket/12359
+			div.innerHTML = "<select><option selected=''></option></select>";
+
+			// IE8 - Some boolean attributes are not treated correctly
+			if ( !div.querySelectorAll("[selected]").length ) {
+				rbuggyQSA.push( "\\[" + whitespace + "*(?:checked|disabled|ismap|multiple|readonly|selected|value)" );
+			}
+
+			// Webkit/Opera - :checked should return selected option elements
+			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
+			// IE8 throws error here (do not put tests after this one)
+			if ( !div.querySelectorAll(":checked").length ) {
+				rbuggyQSA.push(":checked");
+			}
+		});
+
+		assert(function( div ) {
+
+			// Opera 10-12/IE9 - ^= $= *= and empty values
+			// Should not select anything
+			div.innerHTML = "<p test=''></p>";
+			if ( div.querySelectorAll("[test^='']").length ) {
+				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:\"\"|'')" );
+			}
+
+			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
+			// IE8 throws error here (do not put tests after this one)
+			div.innerHTML = "<input type='hidden'/>";
+			if ( !div.querySelectorAll(":enabled").length ) {
+				rbuggyQSA.push(":enabled", ":disabled");
+			}
+		});
+
+		// rbuggyQSA always contains :focus, so no need for a length check
+		rbuggyQSA = /* rbuggyQSA.length && */ new RegExp( rbuggyQSA.join("|") );
+
+		select = function( selector, context, results, seed, xml ) {
+			// Only use querySelectorAll when not filtering,
+			// when this is not xml,
+			// and when no QSA bugs apply
+			if ( !seed && !xml && (!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
+				var groups, i,
+					old = true,
+					nid = expando,
+					newContext = context,
+					newSelector = context.nodeType === 9 && selector;
+
+				// qSA works strangely on Element-rooted queries
+				// We can work around this by specifying an extra ID on the root
+				// and working up from there (Thanks to Andrew Dupont for the technique)
+				// IE 8 doesn't work on object elements
+				if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
+					groups = tokenize( selector );
+
+					if ( (old = context.getAttribute("id")) ) {
+						nid = old.replace( rescape, "\\$&" );
+					} else {
+						context.setAttribute( "id", nid );
+					}
+					nid = "[id='" + nid + "'] ";
+
+					i = groups.length;
+					while ( i-- ) {
+						groups[i] = nid + groups[i].join("");
+					}
+					newContext = rsibling.test( selector ) && context.parentNode || context;
+					newSelector = groups.join(",");
+				}
+
+				if ( newSelector ) {
+					try {
+						push.apply( results, slice.call( newContext.querySelectorAll(
+							newSelector
+						), 0 ) );
+						return results;
+					} catch(qsaError) {
+					} finally {
+						if ( !old ) {
+							context.removeAttribute("id");
+						}
+					}
+				}
+			}
+
+			return oldSelect( selector, context, results, seed, xml );
+		};
+
+		if ( matches ) {
+			assert(function( div ) {
+				// Check to see if it's possible to do matchesSelector
+				// on a disconnected node (IE 9)
+				disconnectedMatch = matches.call( div, "div" );
+
+				// This should fail with an exception
+				// Gecko does not error, returns false instead
+				try {
+					matches.call( div, "[test!='']:sizzle" );
+					rbuggyMatches.push( "!=", pseudos );
+				} catch ( e ) {}
+			});
+
+			// rbuggyMatches always contains :active and :focus, so no need for a length check
+			rbuggyMatches = /* rbuggyMatches.length && */ new RegExp( rbuggyMatches.join("|") );
+
+			Sizzle.matchesSelector = function( elem, expr ) {
+				// Make sure that attribute selectors are quoted
+				expr = expr.replace( rattributeQuotes, "='$1']" );
+
+				// rbuggyMatches always contains :active, so no need for an existence check
+				if ( !isXML( elem ) && !rbuggyMatches.test( expr ) && (!rbuggyQSA || !rbuggyQSA.test( expr )) ) {
+					try {
+						var ret = matches.call( elem, expr );
+
+						// IE 9's matchesSelector returns false on disconnected nodes
+						if ( ret || disconnectedMatch ||
+								// As well, disconnected nodes are said to be in a document
+								// fragment in IE 9
+								elem.document && elem.document.nodeType !== 11 ) {
+							return ret;
+						}
+					} catch(e) {}
+				}
+
+				return Sizzle( expr, null, null, [ elem ] ).length > 0;
+			};
+		}
+	})();
+}
+
+// Deprecated
+Expr.pseudos["nth"] = Expr.pseudos["eq"];
+
+// Back-compat
+function setFilters() {}
+Expr.filters = setFilters.prototype = Expr.pseudos;
+Expr.setFilters = new setFilters();
+
+// Override sizzle attribute retrieval
+Sizzle.attr = jQuery.attr;
+jQuery.find = Sizzle;
+jQuery.expr = Sizzle.selectors;
+jQuery.expr[":"] = jQuery.expr.pseudos;
+jQuery.unique = Sizzle.uniqueSort;
+jQuery.text = Sizzle.getText;
+jQuery.isXMLDoc = Sizzle.isXML;
+jQuery.contains = Sizzle.contains;
+
+
+})( window );
+var runtil = /Until$/,
+	rparentsprev = /^(?:parents|prev(?:Until|All))/,
+	isSimple = /^.[^:#\[\.,]*$/,
+	rneedsContext = jQuery.expr.match.needsContext,
+	// methods guaranteed to produce a unique set when starting from a unique set
+	guaranteedUnique = {
+		children: true,
+		contents: true,
+		next: true,
+		prev: true
+	};
+
+jQuery.fn.extend({
+	find: function( selector ) {
+		var i, l, length, n, r, ret,
+			self = this;
+
+		if ( typeof selector !== "string" ) {
+			return jQuery( selector ).filter(function() {
+				for ( i = 0, l = self.length; i < l; i++ ) {
+					if ( jQuery.contains( self[ i ], this ) ) {
+						return true;
+					}
+				}
+			});
+		}
+
+		ret = this.pushStack( "", "find", selector );
+
+		for ( i = 0, l = this.length; i < l; i++ ) {
+			length = ret.length;
+			jQuery.find( selector, this[i], ret );
+
+			if ( i > 0 ) {
+				// Make sure that the results are unique
+				for ( n = length; n < ret.length; n++ ) {
+					for ( r = 0; r < length; r++ ) {
+						if ( ret[r] === ret[n] ) {
+							ret.splice(n--, 1);
+							break;
+						}
+					}
+				}
+			}
+		}
+
+		return ret;
+	},
+
+	has: function( target ) {
+		var i,
+			targets = jQuery( target, this ),
+			len = targets.length;
+
+		return this.filter(function() {
+			for ( i = 0; i < len; i++ ) {
+				if ( jQuery.contains( this, targets[i] ) ) {
+					return true;
+				}
+			}
+		});
+	},
+
+	not: function( selector ) {
+		return this.pushStack( winnow(this, selector, false), "not", selector);
+	},
+
+	filter: function( selector ) {
+		return this.pushStack( winnow(this, selector, true), "filter", selector );
+	},
+
+	is: function( selector ) {
+		return !!selector && (
+			typeof selector === "string" ?
+				// If this is a positional/relative selector, check membership in the returned set
+				// so $("p:first").is("p:last") won't return true for a doc with two "p".
+				rneedsContext.test( selector ) ?
+					jQuery( selector, this.context ).index( this[0] ) >= 0 :
+					jQuery.filter( selector, this ).length > 0 :
+				this.filter( selector ).length > 0 );
+	},
+
+	closest: function( selectors, context ) {
+		var cur,
+			i = 0,
+			l = this.length,
+			ret = [],
+			pos = rneedsContext.test( selectors ) || typeof selectors !== "string" ?
+				jQuery( selectors, context || this.context ) :
+				0;
+
+		for ( ; i < l; i++ ) {
+			cur = this[i];
+
+			while ( cur && cur.ownerDocument && cur !== context && cur.nodeType !== 11 ) {
+				if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
+					ret.push( cur );
+					break;
+				}
+				cur = cur.parentNode;
+			}
+		}
+
+		ret = ret.length > 1 ? jQuery.unique( ret ) : ret;
+
+		return this.pushStack( ret, "closest", selectors );
+	},
+
+	// Determine the position of an element within
+	// the matched set of elements
+	index: function( elem ) {
+
+		// No argument, return index in parent
+		if ( !elem ) {
+			return ( this[0] && this[0].parentNode ) ? this.prevAll().length : -1;
+		}
+
+		// index in selector
+		if ( typeof elem === "string" ) {
+			return jQuery.inArray( this[0], jQuery( elem ) );
+		}
+
+		// Locate the position of the desired element
+		return jQuery.inArray(
+			// If it receives a jQuery object, the first element is used
+			elem.jquery ? elem[0] : elem, this );
+	},
+
+	add: function( selector, context ) {
+		var set = typeof selector === "string" ?
+				jQuery( selector, context ) :
+				jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ),
+			all = jQuery.merge( this.get(), set );
+
+		return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
+			all :
+			jQuery.unique( all ) );
+	},
+
+	addBack: function( selector ) {
+		return this.add( selector == null ?
+			this.prevObject : this.prevObject.filter(selector)
+		);
+	}
+});
+
+jQuery.fn.andSelf = jQuery.fn.addBack;
+
+// A painfully simple check to see if an element is disconnected
+// from a document (should be improved, where feasible).
+function isDisconnected( node ) {
+	return !node || !node.parentNode || node.parentNode.nodeType === 11;
+}
+
+function sibling( cur, dir ) {
+	do {
+		cur = cur[ dir ];
+	} while ( cur && cur.nodeType !== 1 );
+
+	return cur;
+}
+
+jQuery.each({
+	parent: function( elem ) {
+		var parent = elem.parentNode;
+		return parent && parent.nodeType !== 11 ? parent : null;
+	},
+	parents: function( elem ) {
+		return jQuery.dir( elem, "parentNode" );
+	},
+	parentsUntil: function( elem, i, until ) {
+		return jQuery.dir( elem, "parentNode", until );
+	},
+	next: function( elem ) {
+		return sibling( elem, "nextSibling" );
+	},
+	prev: function( elem ) {
+		return sibling( elem, "previousSibling" );
+	},
+	nextAll: function( elem ) {
+		return jQuery.dir( elem, "nextSibling" );
+	},
+	prevAll: function( elem ) {
+		return jQuery.dir( elem, "previousSibling" );
+	},
+	nextUntil: function( elem, i, until ) {
+		return jQuery.dir( elem, "nextSibling", until );
+	},
+	prevUntil: function( elem, i, until ) {
+		return jQuery.dir( elem, "previousSibling", until );
+	},
+	siblings: function( elem ) {
+		return jQuery.sibling( ( elem.parentNode || {} ).firstChild, elem );
+	},
+	children: function( elem ) {
+		return jQuery.sibling( elem.firstChild );
+	},
+	contents: function( elem ) {
+		return jQuery.nodeName( elem, "iframe" ) ?
+			elem.contentDocument || elem.contentWindow.document :
+			jQuery.merge( [], elem.childNodes );
+	}
+}, function( name, fn ) {
+	jQuery.fn[ name ] = function( until, selector ) {
+		var ret = jQuery.map( this, fn, until );
+
+		if ( !runtil.test( name ) ) {
+			selector = until;
+		}
+
+		if ( selector && typeof selector === "string" ) {
+			ret = jQuery.filter( selector, ret );
+		}
+
+		ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;
+
+		if ( this.length > 1 && rparentsprev.test( name ) ) {
+			ret = ret.reverse();
+		}
+
+		return this.pushStack( ret, name, core_slice.call( arguments ).join(",") );
+	};
+});
+
+jQuery.extend({
+	filter: function( expr, elems, not ) {
+		if ( not ) {
+			expr = ":not(" + expr + ")";
+		}
+
+		return elems.length === 1 ?
+			jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
+			jQuery.find.matches(expr, elems);
+	},
+
+	dir: function( elem, dir, until ) {
+		var matched = [],
+			cur = elem[ dir ];
+
+		while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
+			if ( cur.nodeType === 1 ) {
+				matched.push( cur );
+			}
+			cur = cur[dir];
+		}
+		return matched;
+	},
+
+	sibling: function( n, elem ) {
+		var r = [];
+
+		for ( ; n; n = n.nextSibling ) {
+			if ( n.nodeType === 1 && n !== elem ) {
+				r.push( n );
+			}
+		}
+
+		return r;
+	}
+});
+
+// Implement the identical functionality for filter and not
+function winnow( elements, qualifier, keep ) {
+
+	// Can't pass null or undefined to indexOf in Firefox 4
+	// Set to 0 to skip string check
+	qualifier = qualifier || 0;
+
+	if ( jQuery.isFunction( qualifier ) ) {
+		return jQuery.grep(elements, function( elem, i ) {
+			var retVal = !!qualifier.call( elem, i, elem );
+			return retVal === keep;
+		});
+
+	} else if ( qualifier.nodeType ) {
+		return jQuery.grep(elements, function( elem, i ) {
+			return ( elem === qualifier ) === keep;
+		});
+
+	} else if ( typeof qualifier === "string" ) {
+		var filtered = jQuery.grep(elements, function( elem ) {
+			return elem.nodeType === 1;
+		});
+
+		if ( isSimple.test( qualifier ) ) {
+			return jQuery.filter(qualifier, filtered, !keep);
+		} else {
+			qualifier = jQuery.filter( qualifier, filtered );
+		}
+	}
+
+	return jQuery.grep(elements, function( elem, i ) {
+		return ( jQuery.inArray( elem, qualifier ) >= 0 ) === keep;
+	});
+}
+function createSafeFragment( document ) {
+	var list = nodeNames.split( "|" ),
+	safeFrag = document.createDocumentFragment();
+
+	if ( safeFrag.createElement ) {
+		while ( list.length ) {
+			safeFrag.createElement(
+				list.pop()
+			);
+		}
+	}
+	return safeFrag;
+}
+
+var nodeNames = "abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|" +
+		"header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",
+	rinlinejQuery = / jQuery\d+="(?:null|\d+)"/g,
+	rleadingWhitespace = /^\s+/,
+	rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,
+	rtagName = /<([\w:]+)/,
+	rtbody = /<tbody/i,
+	rhtml = /<|&#?\w+;/,
+	rnoInnerhtml = /<(?:script|style|link)/i,
+	rnocache = /<(?:script|object|embed|option|style)/i,
+	rnoshimcache = new RegExp("<(?:" + nodeNames + ")[\\s/>]", "i"),
+	rcheckableType = /^(?:checkbox|radio)$/,
+	// checked="checked" or checked
+	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
+	rscriptType = /\/(java|ecma)script/i,
+	rcleanScript = /^\s*<!(?:\[CDATA\[|\-\-)|[\]\-]{2}>\s*$/g,
+	wrapMap = {
+		option: [ 1, "<select multiple='multiple'>", "</select>" ],
+		legend: [ 1, "<fieldset>", "</fieldset>" ],
+		thead: [ 1, "<table>", "</table>" ],
+		tr: [ 2, "<table><tbody>", "</tbody></table>" ],
+		td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
+		col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
+		area: [ 1, "<map>", "</map>" ],
+		_default: [ 0, "", "" ]
+	},
+	safeFragment = createSafeFragment( document ),
+	fragmentDiv = safeFragment.appendChild( document.createElement("div") );
+
+wrapMap.optgroup = wrapMap.option;
+wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
+wrapMap.th = wrapMap.td;
+
+// IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags,
+// unless wrapped in a div with non-breaking characters in front of it.
+if ( !jQuery.support.htmlSerialize ) {
+	wrapMap._default = [ 1, "X<div>", "</div>" ];
+}
+
+jQuery.fn.extend({
+	text: function( value ) {
+		return jQuery.access( this, function( value ) {
+			return value === undefined ?
+				jQuery.text( this ) :
+				this.empty().append( ( this[0] && this[0].ownerDocument || document ).createTextNode( value ) );
+		}, null, value, arguments.length );
+	},
+
+	wrapAll: function( html ) {
+		if ( jQuery.isFunction( html ) ) {
+			return this.each(function(i) {
+				jQuery(this).wrapAll( html.call(this, i) );
+			});
+		}
+
+		if ( this[0] ) {
+			// The elements to wrap the target around
+			var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
+
+			if ( this[0].parentNode ) {
+				wrap.insertBefore( this[0] );
+			}
+
+			wrap.map(function() {
+				var elem = this;
+
+				while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
+					elem = elem.firstChild;
+				}
+
+				return elem;
+			}).append( this );
+		}
+
+		return this;
+	},
+
+	wrapInner: function( html ) {
+		if ( jQuery.isFunction( html ) ) {
+			return this.each(function(i) {
+				jQuery(this).wrapInner( html.call(this, i) );
+			});
+		}
+
+		return this.each(function() {
+			var self = jQuery( this ),
+				contents = self.contents();
+
+			if ( contents.length ) {
+				contents.wrapAll( html );
+
+			} else {
+				self.append( html );
+			}
+		});
+	},
+
+	wrap: function( html ) {
+		var isFunction = jQuery.isFunction( html );
+
+		return this.each(function(i) {
+			jQuery( this ).wrapAll( isFunction ? html.call(this, i) : html );
+		});
+	},
+
+	unwrap: function() {
+		return this.parent().each(function() {
+			if ( !jQuery.nodeName( this, "body" ) ) {
+				jQuery( this ).replaceWith( this.childNodes );
+			}
+		}).end();
+	},
+
+	append: function() {
+		return this.domManip(arguments, true, function( elem ) {
+			if ( this.nodeType === 1 || this.nodeType === 11 ) {
+				this.appendChild( elem );
+			}
+		});
+	},
+
+	prepend: function() {
+		return this.domManip(arguments, true, function( elem ) {
+			if ( this.nodeType === 1 || this.nodeType === 11 ) {
+				this.insertBefore( elem, this.firstChild );
+			}
+		});
+	},
+
+	before: function() {
+		if ( !isDisconnected( this[0] ) ) {
+			return this.domManip(arguments, false, function( elem ) {
+				this.parentNode.insertBefore( elem, this );
+			});
+		}
+
+		if ( arguments.length ) {
+			var set = jQuery.clean( arguments );
+			return this.pushStack( jQuery.merge( set, this ), "before", this.selector );
+		}
+	},
+
+	after: function() {
+		if ( !isDisconnected( this[0] ) ) {
+			return this.domManip(arguments, false, function( elem ) {
+				this.parentNode.insertBefore( elem, this.nextSibling );
+			});
+		}
+
+		if ( arguments.length ) {
+			var set = jQuery.clean( arguments );
+			return this.pushStack( jQuery.merge( this, set ), "after", this.selector );
+		}
+	},
+
+	// keepData is for internal use only--do not document
+	remove: function( selector, keepData ) {
+		var elem,
+			i = 0;
+
+		for ( ; (elem = this[i]) != null; i++ ) {
+			if ( !selector || jQuery.filter( selector, [ elem ] ).length ) {
+				if ( !keepData && elem.nodeType === 1 ) {
+					jQuery.cleanData( elem.getElementsByTagName("*") );
+					jQuery.cleanData( [ elem ] );
+				}
+
+				if ( elem.parentNode ) {
+					elem.parentNode.removeChild( elem );
+				}
+			}
+		}
+
+		return this;
+	},
+
+	empty: function() {
+		var elem,
+			i = 0;
+
+		for ( ; (elem = this[i]) != null; i++ ) {
+			// Remove element nodes and prevent memory leaks
+			if ( elem.nodeType === 1 ) {
+				jQuery.cleanData( elem.getElementsByTagName("*") );
+			}
+
+			// Remove any remaining nodes
+			while ( elem.firstChild ) {
+				elem.removeChild( elem.firstChild );
+			}
+		}
+
+		return this;
+	},
+
+	clone: function( dataAndEvents, deepDataAndEvents ) {
+		dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
+		deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
+
+		return this.map( function () {
+			return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
+		});
+	},
+
+	html: function( value ) {
+		return jQuery.access( this, function( value ) {
+			var elem = this[0] || {},
+				i = 0,
+				l = this.length;
+
+			if ( value === undefined ) {
+				return elem.nodeType === 1 ?
+					elem.innerHTML.replace( rinlinejQuery, "" ) :
+					undefined;
+			}
+
+			// See if we can take a shortcut and just use innerHTML
+			if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
+				( jQuery.support.htmlSerialize || !rnoshimcache.test( value )  ) &&
+				( jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value ) ) &&
+				!wrapMap[ ( rtagName.exec( value ) || ["", ""] )[1].toLowerCase() ] ) {
+
+				value = value.replace( rxhtmlTag, "<$1></$2>" );
+
+				try {
+					for (; i < l; i++ ) {
+						// Remove element nodes and prevent memory leaks
+						elem = this[i] || {};
+						if ( elem.nodeType === 1 ) {
+							jQuery.cleanData( elem.getElementsByTagName( "*" ) );
+							elem.innerHTML = value;
+						}
+					}
+
+					elem = 0;
+
+				// If using innerHTML throws an exception, use the fallback method
+				} catch(e) {}
+			}
+
+			if ( elem ) {
+				this.empty().append( value );
+			}
+		}, null, value, arguments.length );
+	},
+
+	replaceWith: function( value ) {
+		if ( !isDisconnected( this[0] ) ) {
+			// Make sure that the elements are removed from the DOM before they are inserted
+			// this can help fix replacing a parent with child elements
+			if ( jQuery.isFunction( value ) ) {
+				return this.each(function(i) {
+					var self = jQuery(this), old = self.html();
+					self.replaceWith( value.call( this, i, old ) );
+				});
+			}
+
+			if ( typeof value !== "string" ) {
+				value = jQuery( value ).detach();
+			}
+
+			return this.each(function() {
+				var next = this.nextSibling,
+					parent = this.parentNode;
+
+				jQuery( this ).remove();
+
+				if ( next ) {
+					jQuery(next).before( value );
+				} else {
+					jQuery(parent).append( value );
+				}
+			});
+		}
+
+		return this.length ?
+			this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value ) :
+			this;
+	},
+
+	detach: function( selector ) {
+		return this.remove( selector, true );
+	},
+
+	domManip: function( args, table, callback ) {
+
+		// Flatten any nested arrays
+		args = [].concat.apply( [], args );
+
+		var results, first, fragment, iNoClone,
+			i = 0,
+			value = args[0],
+			scripts = [],
+			l = this.length;
+
+		// We can't cloneNode fragments that contain checked, in WebKit
+		if ( !jQuery.support.checkClone && l > 1 && typeof value === "string" && rchecked.test( value ) ) {
+			return this.each(function() {
+				jQuery(this).domManip( args, table, callback );
+			});
+		}
+
+		if ( jQuery.isFunction(value) ) {
+			return this.each(function(i) {
+				var self = jQuery(this);
+				args[0] = value.call( this, i, table ? self.html() : undefined );
+				self.domManip( args, table, callback );
+			});
+		}
+
+		if ( this[0] ) {
+			results = jQuery.buildFragment( args, this, scripts );
+			fragment = results.fragment;
+			first = fragment.firstChild;
+
+			if ( fragment.childNodes.length === 1 ) {
+				fragment = first;
+			}
+
+			if ( first ) {
+				table = table && jQuery.nodeName( first, "tr" );
+
+				// Use the original fragment for the last item instead of the first because it can end up
+				// being emptied incorrectly in certain situations (#8070).
+				// Fragments from the fragment cache must always be cloned and never used in place.
+				for ( iNoClone = results.cacheable || l - 1; i < l; i++ ) {
+					callback.call(
+						table && jQuery.nodeName( this[i], "table" ) ?
+							findOrAppend( this[i], "tbody" ) :
+							this[i],
+						i === iNoClone ?
+							fragment :
+							jQuery.clone( fragment, true, true )
+					);
+				}
+			}
+
+			// Fix #11809: Avoid leaking memory
+			fragment = first = null;
+
+			if ( scripts.length ) {
+				jQuery.each( scripts, function( i, elem ) {
+					if ( elem.src ) {
+						if ( jQuery.ajax ) {
+							jQuery.ajax({
+								url: elem.src,
+								type: "GET",
+								dataType: "script",
+								async: false,
+								global: false,
+								"throws": true
+							});
+						} else {
+							jQuery.error("no ajax");
+						}
+					} else {
+						jQuery.globalEval( ( elem.text || elem.textContent || elem.innerHTML || "" ).replace( rcleanScript, "" ) );
+					}
+
+					if ( elem.parentNode ) {
+						elem.parentNode.removeChild( elem );
+					}
+				});
+			}
+		}
+
+		return this;
+	}
+});
+
+function findOrAppend( elem, tag ) {
+	return elem.getElementsByTagName( tag )[0] || elem.appendChild( elem.ownerDocument.createElement( tag ) );
+}
+
+function cloneCopyEvent( src, dest ) {
+
+	if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
+		return;
+	}
+
+	var type, i, l,
+		oldData = jQuery._data( src ),
+		curData = jQuery._data( dest, oldData ),
+		events = oldData.events;
+
+	if ( events ) {
+		delete curData.handle;
+		curData.events = {};
+
+		for ( type in events ) {
+			for ( i = 0, l = events[ type ].length; i < l; i++ ) {
+				jQuery.event.add( dest, type, events[ type ][ i ] );
+			}
+		}
+	}
+
+	// make the cloned public data object a copy from the original
+	if ( curData.data ) {
+		curData.data = jQuery.extend( {}, curData.data );
+	}
+}
+
+function cloneFixAttributes( src, dest ) {
+	var nodeName;
+
+	// We do not need to do anything for non-Elements
+	if ( dest.nodeType !== 1 ) {
+		return;
+	}
+
+	// clearAttributes removes the attributes, which we don't want,
+	// but also removes the attachEvent events, which we *do* want
+	if ( dest.clearAttributes ) {
+		dest.clearAttributes();
+	}
+
+	// mergeAttributes, in contrast, only merges back on the
+	// original attributes, not the events
+	if ( dest.mergeAttributes ) {
+		dest.mergeAttributes( src );
+	}
+
+	nodeName = dest.nodeName.toLowerCase();
+
+	if ( nodeName === "object" ) {
+		// IE6-10 improperly clones children of object elements using classid.
+		// IE10 throws NoModificationAllowedError if parent is null, #12132.
+		if ( dest.parentNode ) {
+			dest.outerHTML = src.outerHTML;
+		}
+
+		// This path appears unavoidable for IE9. When cloning an object
+		// element in IE9, the outerHTML strategy above is not sufficient.
+		// If the src has innerHTML and the destination does not,
+		// copy the src.innerHTML into the dest.innerHTML. #10324
+		if ( jQuery.support.html5Clone && (src.innerHTML && !jQuery.trim(dest.innerHTML)) ) {
+			dest.innerHTML = src.innerHTML;
+		}
+
+	} else if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
+		// IE6-8 fails to persist the checked state of a cloned checkbox
+		// or radio button. Worse, IE6-7 fail to give the cloned element
+		// a checked appearance if the defaultChecked value isn't also set
+
+		dest.defaultChecked = dest.checked = src.checked;
+
+		// IE6-7 get confused and end up setting the value of a cloned
+		// checkbox/radio button to an empty string instead of "on"
+		if ( dest.value !== src.value ) {
+			dest.value = src.value;
+		}
+
+	// IE6-8 fails to return the selected option to the default selected
+	// state when cloning options
+	} else if ( nodeName === "option" ) {
+		dest.selected = src.defaultSelected;
+
+	// IE6-8 fails to set the defaultValue to the correct value when
+	// cloning other types of input fields
+	} else if ( nodeName === "input" || nodeName === "textarea" ) {
+		dest.defaultValue = src.defaultValue;
+
+	// IE blanks contents when cloning scripts
+	} else if ( nodeName === "script" && dest.text !== src.text ) {
+		dest.text = src.text;
+	}
+
+	// Event data gets referenced instead of copied if the expando
+	// gets copied too
+	dest.removeAttribute( jQuery.expando );
+}
+
+jQuery.buildFragment = function( args, context, scripts ) {
+	var fragment, cacheable, cachehit,
+		first = args[ 0 ];
+
+	// Set context from what may come in as undefined or a jQuery collection or a node
+	// Updated to fix #12266 where accessing context[0] could throw an exception in IE9/10 &
+	// also doubles as fix for #8950 where plain objects caused createDocumentFragment exception
+	context = context || document;
+	context = !context.nodeType && context[0] || context;
+	context = context.ownerDocument || context;
+
+	// Only cache "small" (1/2 KB) HTML strings that are associated with the main document
+	// Cloning options loses the selected state, so don't cache them
+	// IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
+	// Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
+	// Lastly, IE6,7,8 will not correctly reuse cached fragments that were created from unknown elems #10501
+	if ( args.length === 1 && typeof first === "string" && first.length < 512 && context === document &&
+		first.charAt(0) === "<" && !rnocache.test( first ) &&
+		(jQuery.support.checkClone || !rchecked.test( first )) &&
+		(jQuery.support.html5Clone || !rnoshimcache.test( first )) ) {
+
+		// Mark cacheable and look for a hit
+		cacheable = true;
+		fragment = jQuery.fragments[ first ];
+		cachehit = fragment !== undefined;
+	}
+
+	if ( !fragment ) {
+		fragment = context.createDocumentFragment();
+		jQuery.clean( args, context, fragment, scripts );
+
+		// Update the cache, but only store false
+		// unless this is a second parsing of the same content
+		if ( cacheable ) {
+			jQuery.fragments[ first ] = cachehit && fragment;
+		}
+	}
+
+	return { fragment: fragment, cacheable: cacheable };
+};
+
+jQuery.fragments = {};
+
+jQuery.each({
+	appendTo: "append",
+	prependTo: "prepend",
+	insertBefore: "before",
+	insertAfter: "after",
+	replaceAll: "replaceWith"
+}, function( name, original ) {
+	jQuery.fn[ name ] = function( selector ) {
+		var elems,
+			i = 0,
+			ret = [],
+			insert = jQuery( selector ),
+			l = insert.length,
+			parent = this.length === 1 && this[0].parentNode;
+
+		if ( (parent == null || parent && parent.nodeType === 11 && parent.childNodes.length === 1) && l === 1 ) {
+			insert[ original ]( this[0] );
+			return this;
+		} else {
+			for ( ; i < l; i++ ) {
+				elems = ( i > 0 ? this.clone(true) : this ).get();
+				jQuery( insert[i] )[ original ]( elems );
+				ret = ret.concat( elems );
+			}
+
+			return this.pushStack( ret, name, insert.selector );
+		}
+	};
+});
+
+function getAll( elem ) {
+	if ( typeof elem.getElementsByTagName !== "undefined" ) {
+		return elem.getElementsByTagName( "*" );
+
+	} else if ( typeof elem.querySelectorAll !== "undefined" ) {
+		return elem.querySelectorAll( "*" );
+
+	} else {
+		return [];
+	}
+}
+
+// Used in clean, fixes the defaultChecked property
+function fixDefaultChecked( elem ) {
+	if ( rcheckableType.test( elem.type ) ) {
+		elem.defaultChecked = elem.checked;
+	}
+}
+
+jQuery.extend({
+	clone: function( elem, dataAndEvents, deepDataAndEvents ) {
+		var srcElements,
+			destElements,
+			i,
+			clone;
+
+		if ( jQuery.support.html5Clone || jQuery.isXMLDoc(elem) || !rnoshimcache.test( "<" + elem.nodeName + ">" ) ) {
+			clone = elem.cloneNode( true );
+
+		// IE<=8 does not properly clone detached, unknown element nodes
+		} else {
+			fragmentDiv.innerHTML = elem.outerHTML;
+			fragmentDiv.removeChild( clone = fragmentDiv.firstChild );
+		}
+
+		if ( (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) &&
+				(elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
+			// IE copies events bound via attachEvent when using cloneNode.
+			// Calling detachEvent on the clone will also remove the events
+			// from the original. In order to get around this, we use some
+			// proprietary methods to clear the events. Thanks to MooTools
+			// guys for this hotness.
+
+			cloneFixAttributes( elem, clone );
+
+			// Using Sizzle here is crazy slow, so we use getElementsByTagName instead
+			srcElements = getAll( elem );
+			destElements = getAll( clone );
+
+			// Weird iteration because IE will replace the length property
+			// with an element if you are cloning the body and one of the
+			// elements on the page has a name or id of "length"
+			for ( i = 0; srcElements[i]; ++i ) {
+				// Ensure that the destination node is not null; Fixes #9587
+				if ( destElements[i] ) {
+					cloneFixAttributes( srcElements[i], destElements[i] );
+				}
+			}
+		}
+
+		// Copy the events from the original to the clone
+		if ( dataAndEvents ) {
+			cloneCopyEvent( elem, clone );
+
+			if ( deepDataAndEvents ) {
+				srcElements = getAll( elem );
+				destElements = getAll( clone );
+
+				for ( i = 0; srcElements[i]; ++i ) {
+					cloneCopyEvent( srcElements[i], destElements[i] );
+				}
+			}
+		}
+
+		srcElements = destElements = null;
+
+		// Return the cloned set
+		return clone;
+	},
+
+	clean: function( elems, context, fragment, scripts ) {
+		var i, j, elem, tag, wrap, depth, div, hasBody, tbody, len, handleScript, jsTags,
+			safe = context === document && safeFragment,
+			ret = [];
+
+		// Ensure that context is a document
+		if ( !context || typeof context.createDocumentFragment === "undefined" ) {
+			context = document;
+		}
+
+		// Use the already-created safe fragment if context permits
+		for ( i = 0; (elem = elems[i]) != null; i++ ) {
+			if ( typeof elem === "number" ) {
+				elem += "";
+			}
+
+			if ( !elem ) {
+				continue;
+			}
+
+			// Convert html string into DOM nodes
+			if ( typeof elem === "string" ) {
+				if ( !rhtml.test( elem ) ) {
+					elem = context.createTextNode( elem );
+				} else {
+					// Ensure a safe container in which to render the html
+					safe = safe || createSafeFragment( context );
+					div = context.createElement("div");
+					safe.appendChild( div );
+
+					// Fix "XHTML"-style tags in all browsers
+					elem = elem.replace(rxhtmlTag, "<$1></$2>");
+
+					// Go to html and back, then peel off extra wrappers
+					tag = ( rtagName.exec( elem ) || ["", ""] )[1].toLowerCase();
+					wrap = wrapMap[ tag ] || wrapMap._default;
+					depth = wrap[0];
+					div.innerHTML = wrap[1] + elem + wrap[2];
+
+					// Move to the right depth
+					while ( depth-- ) {
+						div = div.lastChild;
+					}
+
+					// Remove IE's autoinserted <tbody> from table fragments
+					if ( !jQuery.support.tbody ) {
+
+						// String was a <table>, *may* have spurious <tbody>
+						hasBody = rtbody.test(elem);
+							tbody = tag === "table" && !hasBody ?
+								div.firstChild && div.firstChild.childNodes :
+
+								// String was a bare <thead> or <tfoot>
+								wrap[1] === "<table>" && !hasBody ?
+									div.childNodes :
+									[];
+
+						for ( j = tbody.length - 1; j >= 0 ; --j ) {
+							if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
+								tbody[ j ].parentNode.removeChild( tbody[ j ] );
+							}
+						}
+					}
+
+					// IE completely kills leading whitespace when innerHTML is used
+					if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
+						div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
+					}
+
+					elem = div.childNodes;
+
+					// Take out of fragment container (we need a fresh div each time)
+					div.parentNode.removeChild( div );
+				}
+			}
+
+			if ( elem.nodeType ) {
+				ret.push( elem );
+			} else {
+				jQuery.merge( ret, elem );
+			}
+		}
+
+		// Fix #11356: Clear elements from safeFragment
+		if ( div ) {
+			elem = div = safe = null;
+		}
+
+		// Reset defaultChecked for any radios and checkboxes
+		// about to be appended to the DOM in IE 6/7 (#8060)
+		if ( !jQuery.support.appendChecked ) {
+			for ( i = 0; (elem = ret[i]) != null; i++ ) {
+				if ( jQuery.nodeName( elem, "input" ) ) {
+					fixDefaultChecked( elem );
+				} else if ( typeof elem.getElementsByTagName !== "undefined" ) {
+					jQuery.grep( elem.getElementsByTagName("input"), fixDefaultChecked );
+				}
+			}
+		}
+
+		// Append elements to a provided document fragment
+		if ( fragment ) {
+			// Special handling of each script element
+			handleScript = function( elem ) {
+				// Check if we consider it executable
+				if ( !elem.type || rscriptType.test( elem.type ) ) {
+					// Detach the script and store it in the scripts array (if provided) or the fragment
+					// Return truthy to indicate that it has been handled
+					return scripts ?
+						scripts.push( elem.parentNode ? elem.parentNode.removeChild( elem ) : elem ) :
+						fragment.appendChild( elem );
+				}
+			};
+
+			for ( i = 0; (elem = ret[i]) != null; i++ ) {
+				// Check if we're done after handling an executable script
+				if ( !( jQuery.nodeName( elem, "script" ) && handleScript( elem ) ) ) {
+					// Append to fragment and handle embedded scripts
+					fragment.appendChild( elem );
+					if ( typeof elem.getElementsByTagName !== "undefined" ) {
+						// handleScript alters the DOM, so use jQuery.merge to ensure snapshot iteration
+						jsTags = jQuery.grep( jQuery.merge( [], elem.getElementsByTagName("script") ), handleScript );
+
+						// Splice the scripts into ret after their former ancestor and advance our index beyond them
+						ret.splice.apply( ret, [i + 1, 0].concat( jsTags ) );
+						i += jsTags.length;
+					}
+				}
+			}
+		}
+
+		return ret;
+	},
+
+	cleanData: function( elems, /* internal */ acceptData ) {
+		var data, id, elem, type,
+			i = 0,
+			internalKey = jQuery.expando,
+			cache = jQuery.cache,
+			deleteExpando = jQuery.support.deleteExpando,
+			special = jQuery.event.special;
+
+		for ( ; (elem = elems[i]) != null; i++ ) {
+
+			if ( acceptData || jQuery.acceptData( elem ) ) {
+
+				id = elem[ internalKey ];
+				data = id && cache[ id ];
+
+				if ( data ) {
+					if ( data.events ) {
+						for ( type in data.events ) {
+							if ( special[ type ] ) {
+								jQuery.event.remove( elem, type );
+
+							// This is a shortcut to avoid jQuery.event.remove's overhead
+							} else {
+								jQuery.removeEvent( elem, type, data.handle );
+							}
+						}
+					}
+
+					// Remove cache only if it was not already removed by jQuery.event.remove
+					if ( cache[ id ] ) {
+
+						delete cache[ id ];
+
+						// IE does not allow us to delete expando properties from nodes,
+						// nor does it have a removeAttribute function on Document nodes;
+						// we must handle all of these cases
+						if ( deleteExpando ) {
+							delete elem[ internalKey ];
+
+						} else if ( elem.removeAttribute ) {
+							elem.removeAttribute( internalKey );
+
+						} else {
+							elem[ internalKey ] = null;
+						}
+
+						jQuery.deletedIds.push( id );
+					}
+				}
+			}
+		}
+	}
+});
+// Limit scope pollution from any deprecated API
+(function() {
+
+var matched, browser;
+
+// Use of jQuery.browser is frowned upon.
+// More details: http://api.jquery.com/jQuery.browser
+// jQuery.uaMatch maintained for back-compat
+jQuery.uaMatch = function( ua ) {
+	ua = ua.toLowerCase();
+
+	var match = /(chrome)[ \/]([\w.]+)/.exec( ua ) ||
+		/(webkit)[ \/]([\w.]+)/.exec( ua ) ||
+		/(opera)(?:.*version|)[ \/]([\w.]+)/.exec( ua ) ||
+		/(msie) ([\w.]+)/.exec( ua ) ||
+		ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec( ua ) ||
+		[];
+
+	return {
+		browser: match[ 1 ] || "",
+		version: match[ 2 ] || "0"
+	};
+};
+
+matched = jQuery.uaMatch( navigator.userAgent );
+browser = {};
+
+if ( matched.browser ) {
+	browser[ matched.browser ] = true;
+	browser.version = matched.version;
+}
+
+// Chrome is Webkit, but Webkit is also Safari.
+if ( browser.chrome ) {
+	browser.webkit = true;
+} else if ( browser.webkit ) {
+	browser.safari = true;
+}
+
+jQuery.browser = browser;
+
+jQuery.sub = function() {
+	function jQuerySub( selector, context ) {
+		return new jQuerySub.fn.init( selector, context );
+	}
+	jQuery.extend( true, jQuerySub, this );
+	jQuerySub.superclass = this;
+	jQuerySub.fn = jQuerySub.prototype = this();
+	jQuerySub.fn.constructor = jQuerySub;
+	jQuerySub.sub = this.sub;
+	jQuerySub.fn.init = function init( selector, context ) {
+		if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
+			context = jQuerySub( context );
+		}
+
+		return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
+	};
+	jQuerySub.fn.init.prototype = jQuerySub.fn;
+	var rootjQuerySub = jQuerySub(document);
+	return jQuerySub;
+};
+
+})();
+var curCSS, iframe, iframeDoc,
+	ralpha = /alpha\([^)]*\)/i,
+	ropacity = /opacity=([^)]*)/,
+	rposition = /^(top|right|bottom|left)$/,
+	// swappable if display is none or starts with table except "table", "table-cell", or "table-caption"
+	// see here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
+	rdisplayswap = /^(none|table(?!-c[ea]).+)/,
+	rmargin = /^margin/,
+	rnumsplit = new RegExp( "^(" + core_pnum + ")(.*)$", "i" ),
+	rnumnonpx = new RegExp( "^(" + core_pnum + ")(?!px)[a-z%]+$", "i" ),
+	rrelNum = new RegExp( "^([-+])=(" + core_pnum + ")", "i" ),
+	elemdisplay = {},
+
+	cssShow = { position: "absolute", visibility: "hidden", display: "block" },
+	cssNormalTransform = {
+		letterSpacing: 0,
+		fontWeight: 400
+	},
+
+	cssExpand = [ "Top", "Right", "Bottom", "Left" ],
+	cssPrefixes = [ "Webkit", "O", "Moz", "ms" ],
+
+	eventsToggle = jQuery.fn.toggle;
+
+// return a css property mapped to a potentially vendor prefixed property
+function vendorPropName( style, name ) {
+
+	// shortcut for names that are not vendor prefixed
+	if ( name in style ) {
+		return name;
+	}
+
+	// check for vendor prefixed names
+	var capName = name.charAt(0).toUpperCase() + name.slice(1),
+		origName = name,
+		i = cssPrefixes.length;
+
+	while ( i-- ) {
+		name = cssPrefixes[ i ] + capName;
+		if ( name in style ) {
+			return name;
+		}
+	}
+
+	return origName;
+}
+
+function isHidden( elem, el ) {
+	elem = el || elem;
+	return jQuery.css( elem, "display" ) === "none" || !jQuery.contains( elem.ownerDocument, elem );
+}
+
+function showHide( elements, show ) {
+	var elem, display,
+		values = [],
+		index = 0,
+		length = elements.length;
+
+	for ( ; index < length; index++ ) {
+		elem = elements[ index ];
+		if ( !elem.style ) {
+			continue;
+		}
+		values[ index ] = jQuery._data( elem, "olddisplay" );
+		if ( show ) {
+			// Reset the inline display of this element to learn if it is
+			// being hidden by cascaded rules or not
+			if ( !values[ index ] && elem.style.display === "none" ) {
+				elem.style.display = "";
+			}
+
+			// Set elements which have been overridden with display: none
+			// in a stylesheet to whatever the default browser style is
+			// for such an element
+			if ( elem.style.display === "" && isHidden( elem ) ) {
+				values[ index ] = jQuery._data( elem, "olddisplay", css_defaultDisplay(elem.nodeName) );
+			}
+		} else {
+			display = curCSS( elem, "display" );
+
+			if ( !values[ index ] && display !== "none" ) {
+				jQuery._data( elem, "olddisplay", display );
+			}
+		}
+	}
+
+	// Set the display of most of the elements in a second loop
+	// to avoid the constant reflow
+	for ( index = 0; index < length; index++ ) {
+		elem = elements[ index ];
+		if ( !elem.style ) {
+			continue;
+		}
+		if ( !show || elem.style.display === "none" || elem.style.display === "" ) {
+			elem.style.display = show ? values[ index ] || "" : "none";
+		}
+	}
+
+	return elements;
+}
+
+jQuery.fn.extend({
+	css: function( name, value ) {
+		return jQuery.access( this, function( elem, name, value ) {
+			return value !== undefined ?
+				jQuery.style( elem, name, value ) :
+				jQuery.css( elem, name );
+		}, name, value, arguments.length > 1 );
+	},
+	show: function() {
+		return showHide( this, true );
+	},
+	hide: function() {
+		return showHide( this );
+	},
+	toggle: function( state, fn2 ) {
+		var bool = typeof state === "boolean";
+
+		if ( jQuery.isFunction( state ) && jQuery.isFunction( fn2 ) ) {
+			return eventsToggle.apply( this, arguments );
+		}
+
+		return this.each(function() {
+			if ( bool ? state : isHidden( this ) ) {
+				jQuery( this ).show();
+			} else {
+				jQuery( this ).hide();
+			}
+		});
+	}
+});
+
+jQuery.extend({
+	// Add in style property hooks for overriding the default
+	// behavior of getting and setting a style property
+	cssHooks: {
+		opacity: {
+			get: function( elem, computed ) {
+				if ( computed ) {
+					// We should always get a number back from opacity
+					var ret = curCSS( elem, "opacity" );
+					return ret === "" ? "1" : ret;
+
+				}
+			}
+		}
+	},
+
+	// Exclude the following css properties to add px
+	cssNumber: {
+		"fillOpacity": true,
+		"fontWeight": true,
+		"lineHeight": true,
+		"opacity": true,
+		"orphans": true,
+		"widows": true,
+		"zIndex": true,
+		"zoom": true
+	},
+
+	// Add in properties whose names you wish to fix before
+	// setting or getting the value
+	cssProps: {
+		// normalize float css property
+		"float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
+	},
+
+	// Get and set the style property on a DOM Node
+	style: function( elem, name, value, extra ) {
+		// Don't set styles on text and comment nodes
+		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
+			return;
+		}
+
+		// Make sure that we're working with the right name
+		var ret, type, hooks,
+			origName = jQuery.camelCase( name ),
+			style = elem.style;
+
+		name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( style, origName ) );
+
+		// gets hook for the prefixed version
+		// followed by the unprefixed version
+		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
+
+		// Check if we're setting a value
+		if ( value !== undefined ) {
+			type = typeof value;
+
+			// convert relative number strings (+= or -=) to relative numbers. #7345
+			if ( type === "string" && (ret = rrelNum.exec( value )) ) {
+				value = ( ret[1] + 1 ) * ret[2] + parseFloat( jQuery.css( elem, name ) );
+				// Fixes bug #9237
+				type = "number";
+			}
+
+			// Make sure that NaN and null values aren't set. See: #7116
+			if ( value == null || type === "number" && isNaN( value ) ) {
+				return;
+			}
+
+			// If a number was passed in, add 'px' to the (except for certain CSS properties)
+			if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
+				value += "px";
+			}
+
+			// If a hook was provided, use that value, otherwise just set the specified value
+			if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value, extra )) !== undefined ) {
+				// Wrapped to prevent IE from throwing errors when 'invalid' values are provided
+				// Fixes bug #5509
+				try {
+					style[ name ] = value;
+				} catch(e) {}
+			}
+
+		} else {
+			// If a hook was provided get the non-computed value from there
+			if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
+				return ret;
+			}
+
+			// Otherwise just get the value from the style object
+			return style[ name ];
+		}
+	},
+
+	css: function( elem, name, numeric, extra ) {
+		var val, num, hooks,
+			origName = jQuery.camelCase( name );
+
+		// Make sure that we're working with the right name
+		name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( elem.style, origName ) );
+
+		// gets hook for the prefixed version
+		// followed by the unprefixed version
+		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
+
+		// If a hook was provided get the computed value from there
+		if ( hooks && "get" in hooks ) {
+			val = hooks.get( elem, true, extra );
+		}
+
+		// Otherwise, if a way to get the computed value exists, use that
+		if ( val === undefined ) {
+			val = curCSS( elem, name );
+		}
+
+		//convert "normal" to computed value
+		if ( val === "normal" && name in cssNormalTransform ) {
+			val = cssNormalTransform[ name ];
+		}
+
+		// Return, converting to number if forced or a qualifier was provided and val looks numeric
+		if ( numeric || extra !== undefined ) {
+			num = parseFloat( val );
+			return numeric || jQuery.isNumeric( num ) ? num || 0 : val;
+		}
+		return val;
+	},
+
+	// A method for quickly swapping in/out CSS properties to get correct calculations
+	swap: function( elem, options, callback ) {
+		var ret, name,
+			old = {};
+
+		// Remember the old values, and insert the new ones
+		for ( name in options ) {
+			old[ name ] = elem.style[ name ];
+			elem.style[ name ] = options[ name ];
+		}
+
+		ret = callback.call( elem );
+
+		// Revert the old values
+		for ( name in options ) {
+			elem.style[ name ] = old[ name ];
+		}
+
+		return ret;
+	}
+});
+
+// NOTE: To any future maintainer, we've window.getComputedStyle
+// because jsdom on node.js will break without it.
+if ( window.getComputedStyle ) {
+	curCSS = function( elem, name ) {
+		var ret, width, minWidth, maxWidth,
+			computed = window.getComputedStyle( elem, null ),
+			style = elem.style;
+
+		if ( computed ) {
+
+			ret = computed[ name ];
+			if ( ret === "" && !jQuery.contains( elem.ownerDocument, elem ) ) {
+				ret = jQuery.style( elem, name );
+			}
+
+			// A tribute to the "awesome hack by Dean Edwards"
+			// Chrome < 17 and Safari 5.0 uses "computed value" instead of "used value" for margin-right
+			// Safari 5.1.7 (at least) returns percentage for a larger set of values, but width seems to be reliably pixels
+			// this is against the CSSOM draft spec: http://dev.w3.org/csswg/cssom/#resolved-values
+			if ( rnumnonpx.test( ret ) && rmargin.test( name ) ) {
+				width = style.width;
+				minWidth = style.minWidth;
+				maxWidth = style.maxWidth;
+
+				style.minWidth = style.maxWidth = style.width = ret;
+				ret = computed.width;
+
+				style.width = width;
+				style.minWidth = minWidth;
+				style.maxWidth = maxWidth;
+			}
+		}
+
+		return ret;
+	};
+} else if ( document.documentElement.currentStyle ) {
+	curCSS = function( elem, name ) {
+		var left, rsLeft,
+			ret = elem.currentStyle && elem.currentStyle[ name ],
+			style = elem.style;
+
+		// Avoid setting ret to empty string here
+		// so we don't default to auto
+		if ( ret == null && style && style[ name ] ) {
+			ret = style[ name ];
+		}
+
+		// From the awesome hack by Dean Edwards
+		// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
+
+		// If we're not dealing with a regular pixel number
+		// but a number that has a weird ending, we need to convert it to pixels
+		// but not position css attributes, as those are proportional to the parent element instead
+		// and we can't measure the parent instead because it might trigger a "stacking dolls" problem
+		if ( rnumnonpx.test( ret ) && !rposition.test( name ) ) {
+
+			// Remember the original values
+			left = style.left;
+			rsLeft = elem.runtimeStyle && elem.runtimeStyle.left;
+
+			// Put in the new values to get a computed value out
+			if ( rsLeft ) {
+				elem.runtimeStyle.left = elem.currentStyle.left;
+			}
+			style.left = name === "fontSize" ? "1em" : ret;
+			ret = style.pixelLeft + "px";
+
+			// Revert the changed values
+			style.left = left;
+			if ( rsLeft ) {
+				elem.runtimeStyle.left = rsLeft;
+			}
+		}
+
+		return ret === "" ? "auto" : ret;
+	};
+}
+
+function setPositiveNumber( elem, value, subtract ) {
+	var matches = rnumsplit.exec( value );
+	return matches ?
+			Math.max( 0, matches[ 1 ] - ( subtract || 0 ) ) + ( matches[ 2 ] || "px" ) :
+			value;
+}
+
+function augmentWidthOrHeight( elem, name, extra, isBorderBox ) {
+	var i = extra === ( isBorderBox ? "border" : "content" ) ?
+		// If we already have the right measurement, avoid augmentation
+		4 :
+		// Otherwise initialize for horizontal or vertical properties
+		name === "width" ? 1 : 0,
+
+		val = 0;
+
+	for ( ; i < 4; i += 2 ) {
+		// both box models exclude margin, so add it if we want it
+		if ( extra === "margin" ) {
+			// we use jQuery.css instead of curCSS here
+			// because of the reliableMarginRight CSS hook!
+			val += jQuery.css( elem, extra + cssExpand[ i ], true );
+		}
+
+		// From this point on we use curCSS for maximum performance (relevant in animations)
+		if ( isBorderBox ) {
+			// border-box includes padding, so remove it if we want content
+			if ( extra === "content" ) {
+				val -= parseFloat( curCSS( elem, "padding" + cssExpand[ i ] ) ) || 0;
+			}
+
+			// at this point, extra isn't border nor margin, so remove border
+			if ( extra !== "margin" ) {
+				val -= parseFloat( curCSS( elem, "border" + cssExpand[ i ] + "Width" ) ) || 0;
+			}
+		} else {
+			// at this point, extra isn't content, so add padding
+			val += parseFloat( curCSS( elem, "padding" + cssExpand[ i ] ) ) || 0;
+
+			// at this point, extra isn't content nor padding, so add border
+			if ( extra !== "padding" ) {
+				val += parseFloat( curCSS( elem, "border" + cssExpand[ i ] + "Width" ) ) || 0;
+			}
+		}
+	}
+
+	return val;
+}
+
+function getWidthOrHeight( elem, name, extra ) {
+
+	// Start with offset property, which is equivalent to the border-box value
+	var val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
+		valueIsBorderBox = true,
+		isBorderBox = jQuery.support.boxSizing && jQuery.css( elem, "boxSizing" ) === "border-box";
+
+	// some non-html elements return undefined for offsetWidth, so check for null/undefined
+	// svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
+	// MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
+	if ( val <= 0 || val == null ) {
+		// Fall back to computed then uncomputed css if necessary
+		val = curCSS( elem, name );
+		if ( val < 0 || val == null ) {
+			val = elem.style[ name ];
+		}
+
+		// Computed unit is not pixels. Stop here and return.
+		if ( rnumnonpx.test(val) ) {
+			return val;
+		}
+
+		// we need the check for style in case a browser which returns unreliable values
+		// for getComputedStyle silently falls back to the reliable elem.style
+		valueIsBorderBox = isBorderBox && ( jQuery.support.boxSizingReliable || val === elem.style[ name ] );
+
+		// Normalize "", auto, and prepare for extra
+		val = parseFloat( val ) || 0;
+	}
+
+	// use the active box-sizing model to add/subtract irrelevant styles
+	return ( val +
+		augmentWidthOrHeight(
+			elem,
+			name,
+			extra || ( isBorderBox ? "border" : "content" ),
+			valueIsBorderBox
+		)
+	) + "px";
+}
+
+
+// Try to determine the default display value of an element
+function css_defaultDisplay( nodeName ) {
+	if ( elemdisplay[ nodeName ] ) {
+		return elemdisplay[ nodeName ];
+	}
+
+	var elem = jQuery( "<" + nodeName + ">" ).appendTo( document.body ),
+		display = elem.css("display");
+	elem.remove();
+
+	// If the simple way fails,
+	// get element's real default display by attaching it to a temp iframe
+	if ( display === "none" || display === "" ) {
+		// Use the already-created iframe if possible
+		iframe = document.body.appendChild(
+			iframe || jQuery.extend( document.createElement("iframe"), {
+				frameBorder: 0,
+				width: 0,
+				height: 0
+			})
+		);
+
+		// Create a cacheable copy of the iframe document on first call.
+		// IE and Opera will allow us to reuse the iframeDoc without re-writing the fake HTML
+		// document to it; WebKit & Firefox won't allow reusing the iframe document.
+		if ( !iframeDoc || !iframe.createElement ) {
+			iframeDoc = ( iframe.contentWindow || iframe.contentDocument ).document;
+			iframeDoc.write("<!doctype html><html><body>");
+			iframeDoc.close();
+		}
+
+		elem = iframeDoc.body.appendChild( iframeDoc.createElement(nodeName) );
+
+		display = curCSS( elem, "display" );
+		document.body.removeChild( iframe );
+	}
+
+	// Store the correct default display
+	elemdisplay[ nodeName ] = display;
+
+	return display;
+}
+
+jQuery.each([ "height", "width" ], function( i, name ) {
+	jQuery.cssHooks[ name ] = {
+		get: function( elem, computed, extra ) {
+			if ( computed ) {
+				// certain elements can have dimension info if we invisibly show them
+				// however, it must have a current display style that would benefit from this
+				if ( elem.offsetWidth === 0 && rdisplayswap.test( curCSS( elem, "display" ) ) ) {
+					return jQuery.swap( elem, cssShow, function() {
+						return getWidthOrHeight( elem, name, extra );
+					});
+				} else {
+					return getWidthOrHeight( elem, name, extra );
+				}
+			}
+		},
+
+		set: function( elem, value, extra ) {
+			return setPositiveNumber( elem, value, extra ?
+				augmentWidthOrHeight(
+					elem,
+					name,
+					extra,
+					jQuery.support.boxSizing && jQuery.css( elem, "boxSizing" ) === "border-box"
+				) : 0
+			);
+		}
+	};
+});
+
+if ( !jQuery.support.opacity ) {
+	jQuery.cssHooks.opacity = {
+		get: function( elem, computed ) {
+			// IE uses filters for opacity
+			return ropacity.test( (computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "" ) ?
+				( 0.01 * parseFloat( RegExp.$1 ) ) + "" :
+				computed ? "1" : "";
+		},
+
+		set: function( elem, value ) {
+			var style = elem.style,
+				currentStyle = elem.currentStyle,
+				opacity = jQuery.isNumeric( value ) ? "alpha(opacity=" + value * 100 + ")" : "",
+				filter = currentStyle && currentStyle.filter || style.filter || "";
+
+			// IE has trouble with opacity if it does not have layout
+			// Force it by setting the zoom level
+			style.zoom = 1;
+
+			// if setting opacity to 1, and no other filters exist - attempt to remove filter attribute #6652
+			if ( value >= 1 && jQuery.trim( filter.replace( ralpha, "" ) ) === "" &&
+				style.removeAttribute ) {
+
+				// Setting style.filter to null, "" & " " still leave "filter:" in the cssText
+				// if "filter:" is present at all, clearType is disabled, we want to avoid this
+				// style.removeAttribute is IE Only, but so apparently is this code path...
+				style.removeAttribute( "filter" );
+
+				// if there there is no filter style applied in a css rule, we are done
+				if ( currentStyle && !currentStyle.filter ) {
+					return;
+				}
+			}
+
+			// otherwise, set new filter values
+			style.filter = ralpha.test( filter ) ?
+				filter.replace( ralpha, opacity ) :
+				filter + " " + opacity;
+		}
+	};
+}
+
+// These hooks cannot be added until DOM ready because the support test
+// for it is not run until after DOM ready
+jQuery(function() {
+	if ( !jQuery.support.reliableMarginRight ) {
+		jQuery.cssHooks.marginRight = {
+			get: function( elem, computed ) {
+				// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
+				// Work around by temporarily setting element display to inline-block
+				return jQuery.swap( elem, { "display": "inline-block" }, function() {
+					if ( computed ) {
+						return curCSS( elem, "marginRight" );
+					}
+				});
+			}
+		};
+	}
+
+	// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
+	// getComputedStyle returns percent when specified for top/left/bottom/right
+	// rather than make the css module depend on the offset module, we just check for it here
+	if ( !jQuery.support.pixelPosition && jQuery.fn.position ) {
+		jQuery.each( [ "top", "left" ], function( i, prop ) {
+			jQuery.cssHooks[ prop ] = {
+				get: function( elem, computed ) {
+					if ( computed ) {
+						var ret = curCSS( elem, prop );
+						// if curCSS returns percentage, fallback to offset
+						return rnumnonpx.test( ret ) ? jQuery( elem ).position()[ prop ] + "px" : ret;
+					}
+				}
+			};
+		});
+	}
+
+});
+
+if ( jQuery.expr && jQuery.expr.filters ) {
+	jQuery.expr.filters.hidden = function( elem ) {
+		return ( elem.offsetWidth === 0 && elem.offsetHeight === 0 ) || (!jQuery.support.reliableHiddenOffsets && ((elem.style && elem.style.display) || curCSS( elem, "display" )) === "none");
+	};
+
+	jQuery.expr.filters.visible = function( elem ) {
+		return !jQuery.expr.filters.hidden( elem );
+	};
+}
+
+// These hooks are used by animate to expand properties
+jQuery.each({
+	margin: "",
+	padding: "",
+	border: "Width"
+}, function( prefix, suffix ) {
+	jQuery.cssHooks[ prefix + suffix ] = {
+		expand: function( value ) {
+			var i,
+
+				// assumes a single number if not a string
+				parts = typeof value === "string" ? value.split(" ") : [ value ],
+				expanded = {};
+
+			for ( i = 0; i < 4; i++ ) {
+				expanded[ prefix + cssExpand[ i ] + suffix ] =
+					parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
+			}
+
+			return expanded;
+		}
+	};
+
+	if ( !rmargin.test( prefix ) ) {
+		jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
+	}
+});
+var r20 = /%20/g,
+	rbracket = /\[\]$/,
+	rCRLF = /\r?\n/g,
+	rinput = /^(?:color|date|datetime|datetime-local|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
+	rselectTextarea = /^(?:select|textarea)/i;
+
+jQuery.fn.extend({
+	serialize: function() {
+		return jQuery.param( this.serializeArray() );
+	},
+	serializeArray: function() {
+		return this.map(function(){
+			return this.elements ? jQuery.makeArray( this.elements ) : this;
+		})
+		.filter(function(){
+			return this.name && !this.disabled &&
+				( this.checked || rselectTextarea.test( this.nodeName ) ||
+					rinput.test( this.type ) );
+		})
+		.map(function( i, elem ){
+			var val = jQuery( this ).val();
+
+			return val == null ?
+				null :
+				jQuery.isArray( val ) ?
+					jQuery.map( val, function( val, i ){
+						return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
+					}) :
+					{ name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
+		}).get();
+	}
+});
+
+//Serialize an array of form elements or a set of
+//key/values into a query string
+jQuery.param = function( a, traditional ) {
+	var prefix,
+		s = [],
+		add = function( key, value ) {
+			// If value is a function, invoke it and return its value
+			value = jQuery.isFunction( value ) ? value() : ( value == null ? "" : value );
+			s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
+		};
+
+	// Set traditional to true for jQuery <= 1.3.2 behavior.
+	if ( traditional === undefined ) {
+		traditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional;
+	}
+
+	// If an array was passed in, assume that it is an array of form elements.
+	if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
+		// Serialize the form elements
+		jQuery.each( a, function() {
+			add( this.name, this.value );
+		});
+
+	} else {
+		// If traditional, encode the "old" way (the way 1.3.2 or older
+		// did it), otherwise encode params recursively.
+		for ( prefix in a ) {
+			buildParams( prefix, a[ prefix ], traditional, add );
+		}
+	}
+
+	// Return the resulting serialization
+	return s.join( "&" ).replace( r20, "+" );
+};
+
+function buildParams( prefix, obj, traditional, add ) {
+	var name;
+
+	if ( jQuery.isArray( obj ) ) {
+		// Serialize array item.
+		jQuery.each( obj, function( i, v ) {
+			if ( traditional || rbracket.test( prefix ) ) {
+				// Treat each array item as a scalar.
+				add( prefix, v );
+
+			} else {
+				// If array item is non-scalar (array or object), encode its
+				// numeric index to resolve deserialization ambiguity issues.
+				// Note that rack (as of 1.0.0) can't currently deserialize
+				// nested arrays properly, and attempting to do so may cause
+				// a server error. Possible fixes are to modify rack's
+				// deserialization algorithm or to provide an option or flag
+				// to force array serialization to be shallow.
+				buildParams( prefix + "[" + ( typeof v === "object" ? i : "" ) + "]", v, traditional, add );
+			}
+		});
+
+	} else if ( !traditional && jQuery.type( obj ) === "object" ) {
+		// Serialize object item.
+		for ( name in obj ) {
+			buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
+		}
+
+	} else {
+		// Serialize scalar item.
+		add( prefix, obj );
+	}
+}
+var
+	// Document location
+	ajaxLocParts,
+	ajaxLocation,
+
+	rhash = /#.*$/,
+	rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
+	// #7653, #8125, #8152: local protocol detection
+	rlocalProtocol = /^(?:about|app|app\-storage|.+\-extension|file|res|widget):$/,
+	rnoContent = /^(?:GET|HEAD)$/,
+	rprotocol = /^\/\//,
+	rquery = /\?/,
+	rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
+	rts = /([?&])_=[^&]*/,
+	rurl = /^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+)|)|)/,
+
+	// Keep a copy of the old load method
+	_load = jQuery.fn.load,
+
+	/* Prefilters
+	 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
+	 * 2) These are called:
+	 *    - BEFORE asking for a transport
+	 *    - AFTER param serialization (s.data is a string if s.processData is true)
+	 * 3) key is the dataType
+	 * 4) the catchall symbol "*" can be used
+	 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
+	 */
+	prefilters = {},
+
+	/* Transports bindings
+	 * 1) key is the dataType
+	 * 2) the catchall symbol "*" can be used
+	 * 3) selection will start with transport dataType and THEN go to "*" if needed
+	 */
+	transports = {},
+
+	// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
+	allTypes = ["*/"] + ["*"];
+
+// #8138, IE may throw an exception when accessing
+// a field from window.location if document.domain has been set
+try {
+	ajaxLocation = location.href;
+} catch( e ) {
+	// Use the href attribute of an A element
+	// since IE will modify it given document.location
+	ajaxLocation = document.createElement( "a" );
+	ajaxLocation.href = "";
+	ajaxLocation = ajaxLocation.href;
+}
+
+// Segment location into parts
+ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
+
+// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
+function addToPrefiltersOrTransports( structure ) {
+
+	// dataTypeExpression is optional and defaults to "*"
+	return function( dataTypeExpression, func ) {
+
+		if ( typeof dataTypeExpression !== "string" ) {
+			func = dataTypeExpression;
+			dataTypeExpression = "*";
+		}
+
+		var dataType, list, placeBefore,
+			dataTypes = dataTypeExpression.toLowerCase().split( core_rspace ),
+			i = 0,
+			length = dataTypes.length;
+
+		if ( jQuery.isFunction( func ) ) {
+			// For each dataType in the dataTypeExpression
+			for ( ; i < length; i++ ) {
+				dataType = dataTypes[ i ];
+				// We control if we're asked to add before
+				// any existing element
+				placeBefore = /^\+/.test( dataType );
+				if ( placeBefore ) {
+					dataType = dataType.substr( 1 ) || "*";
+				}
+				list = structure[ dataType ] = structure[ dataType ] || [];
+				// then we add to the structure accordingly
+				list[ placeBefore ? "unshift" : "push" ]( func );
+			}
+		}
+	};
+}
+
+// Base inspection function for prefilters and transports
+function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR,
+		dataType /* internal */, inspected /* internal */ ) {
+
+	dataType = dataType || options.dataTypes[ 0 ];
+	inspected = inspected || {};
+
+	inspected[ dataType ] = true;
+
+	var selection,
+		list = structure[ dataType ],
+		i = 0,
+		length = list ? list.length : 0,
+		executeOnly = ( structure === prefilters );
+
+	for ( ; i < length && ( executeOnly || !selection ); i++ ) {
+		selection = list[ i ]( options, originalOptions, jqXHR );
+		// If we got redirected to another dataType
+		// we try there if executing only and not done already
+		if ( typeof selection === "string" ) {
+			if ( !executeOnly || inspected[ selection ] ) {
+				selection = undefined;
+			} else {
+				options.dataTypes.unshift( selection );
+				selection = inspectPrefiltersOrTransports(
+						structure, options, originalOptions, jqXHR, selection, inspected );
+			}
+		}
+	}
+	// If we're only executing or nothing was selected
+	// we try the catchall dataType if not done already
+	if ( ( executeOnly || !selection ) && !inspected[ "*" ] ) {
+		selection = inspectPrefiltersOrTransports(
+				structure, options, originalOptions, jqXHR, "*", inspected );
+	}
+	// unnecessary when only executing (prefilters)
+	// but it'll be ignored by the caller in that case
+	return selection;
+}
+
+// A special extend for ajax options
+// that takes "flat" options (not to be deep extended)
+// Fixes #9887
+function ajaxExtend( target, src ) {
+	var key, deep,
+		flatOptions = jQuery.ajaxSettings.flatOptions || {};
+	for ( key in src ) {
+		if ( src[ key ] !== undefined ) {
+			( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
+		}
+	}
+	if ( deep ) {
+		jQuery.extend( true, target, deep );
+	}
+}
+
+jQuery.fn.load = function( url, params, callback ) {
+	if ( typeof url !== "string" && _load ) {
+		return _load.apply( this, arguments );
+	}
+
+	// Don't do a request if no elements are being requested
+	if ( !this.length ) {
+		return this;
+	}
+
+	var selector, type, response,
+		self = this,
+		off = url.indexOf(" ");
+
+	if ( off >= 0 ) {
+		selector = url.slice( off, url.length );
+		url = url.slice( 0, off );
+	}
+
+	// If it's a function
+	if ( jQuery.isFunction( params ) ) {
+
+		// We assume that it's the callback
+		callback = params;
+		params = undefined;
+
+	// Otherwise, build a param string
+	} else if ( params && typeof params === "object" ) {
+		type = "POST";
+	}
+
+	// Request the remote document
+	jQuery.ajax({
+		url: url,
+
+		// if "type" variable is undefined, then "GET" method will be used
+		type: type,
+		dataType: "html",
+		data: params,
+		complete: function( jqXHR, status ) {
+			if ( callback ) {
+				self.each( callback, response || [ jqXHR.responseText, status, jqXHR ] );
+			}
+		}
+	}).done(function( responseText ) {
+
+		// Save response for use in complete callback
+		response = arguments;
+
+		// See if a selector was specified
+		self.html( selector ?
+
+			// Create a dummy div to hold the results
+			jQuery("<div>")
+
+				// inject the contents of the document in, removing the scripts
+				// to avoid any 'Permission Denied' errors in IE
+				.append( responseText.replace( rscript, "" ) )
+
+				// Locate the specified elements
+				.find( selector ) :
+
+			// If not, just inject the full result
+			responseText );
+
+	});
+
+	return this;
+};
+
+// Attach a bunch of functions for handling common AJAX events
+jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split( " " ), function( i, o ){
+	jQuery.fn[ o ] = function( f ){
+		return this.on( o, f );
+	};
+});
+
+jQuery.each( [ "get", "post" ], function( i, method ) {
+	jQuery[ method ] = function( url, data, callback, type ) {
+		// shift arguments if data argument was omitted
+		if ( jQuery.isFunction( data ) ) {
+			type = type || callback;
+			callback = data;
+			data = undefined;
+		}
+
+		return jQuery.ajax({
+			type: method,
+			url: url,
+			data: data,
+			success: callback,
+			dataType: type
+		});
+	};
+});
+
+jQuery.extend({
+
+	getScript: function( url, callback ) {
+		return jQuery.get( url, undefined, callback, "script" );
+	},
+
+	getJSON: function( url, data, callback ) {
+		return jQuery.get( url, data, callback, "json" );
+	},
+
+	// Creates a full fledged settings object into target
+	// with both ajaxSettings and settings fields.
+	// If target is omitted, writes into ajaxSettings.
+	ajaxSetup: function( target, settings ) {
+		if ( settings ) {
+			// Building a settings object
+			ajaxExtend( target, jQuery.ajaxSettings );
+		} else {
+			// Extending ajaxSettings
+			settings = target;
+			target = jQuery.ajaxSettings;
+		}
+		ajaxExtend( target, settings );
+		return target;
+	},
+
+	ajaxSettings: {
+		url: ajaxLocation,
+		isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
+		global: true,
+		type: "GET",
+		contentType: "application/x-www-form-urlencoded; charset=UTF-8",
+		processData: true,
+		async: true,
+		/*
+		timeout: 0,
+		data: null,
+		dataType: null,
+		username: null,
+		password: null,
+		cache: null,
+		throws: false,
+		traditional: false,
+		headers: {},
+		*/
+
+		accepts: {
+			xml: "application/xml, text/xml",
+			html: "text/html",
+			text: "text/plain",
+			json: "application/json, text/javascript",
+			"*": allTypes
+		},
+
+		contents: {
+			xml: /xml/,
+			html: /html/,
+			json: /json/
+		},
+
+		responseFields: {
+			xml: "responseXML",
+			text: "responseText"
+		},
+
+		// List of data converters
+		// 1) key format is "source_type destination_type" (a single space in-between)
+		// 2) the catchall symbol "*" can be used for source_type
+		converters: {
+
+			// Convert anything to text
+			"* text": window.String,
+
+			// Text to html (true = no transformation)
+			"text html": true,
+
+			// Evaluate text as a json expression
+			"text json": jQuery.parseJSON,
+
+			// Parse text as xml
+			"text xml": jQuery.parseXML
+		},
+
+		// For options that shouldn't be deep extended:
+		// you can add your own custom options here if
+		// and when you create one that shouldn't be
+		// deep extended (see ajaxExtend)
+		flatOptions: {
+			context: true,
+			url: true
+		}
+	},
+
+	ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
+	ajaxTransport: addToPrefiltersOrTransports( transports ),
+
+	// Main method
+	ajax: function( url, options ) {
+
+		// If url is an object, simulate pre-1.5 signature
+		if ( typeof url === "object" ) {
+			options = url;
+			url = undefined;
+		}
+
+		// Force options to be an object
+		options = options || {};
+
+		var // ifModified key
+			ifModifiedKey,
+			// Response headers
+			responseHeadersString,
+			responseHeaders,
+			// transport
+			transport,
+			// timeout handle
+			timeoutTimer,
+			// Cross-domain detection vars
+			parts,
+			// To know if global events are to be dispatched
+			fireGlobals,
+			// Loop variable
+			i,
+			// Create the final options object
+			s = jQuery.ajaxSetup( {}, options ),
+			// Callbacks context
+			callbackContext = s.context || s,
+			// Context for global events
+			// It's the callbackContext if one was provided in the options
+			// and if it's a DOM node or a jQuery collection
+			globalEventContext = callbackContext !== s &&
+				( callbackContext.nodeType || callbackContext instanceof jQuery ) ?
+						jQuery( callbackContext ) : jQuery.event,
+			// Deferreds
+			deferred = jQuery.Deferred(),
+			completeDeferred = jQuery.Callbacks( "once memory" ),
+			// Status-dependent callbacks
+			statusCode = s.statusCode || {},
+			// Headers (they are sent all at once)
+			requestHeaders = {},
+			requestHeadersNames = {},
+			// The jqXHR state
+			state = 0,
+			// Default abort message
+			strAbort = "canceled",
+			// Fake xhr
+			jqXHR = {
+
+				readyState: 0,
+
+				// Caches the header
+				setRequestHeader: function( name, value ) {
+					if ( !state ) {
+						var lname = name.toLowerCase();
+						name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
+						requestHeaders[ name ] = value;
+					}
+					return this;
+				},
+
+				// Raw string
+				getAllResponseHeaders: function() {
+					return state === 2 ? responseHeadersString : null;
+				},
+
+				// Builds headers hashtable if needed
+				getResponseHeader: function( key ) {
+					var match;
+					if ( state === 2 ) {
+						if ( !responseHeaders ) {
+							responseHeaders = {};
+							while( ( match = rheaders.exec( responseHeadersString ) ) ) {
+								responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
+							}
+						}
+						match = responseHeaders[ key.toLowerCase() ];
+					}
+					return match === undefined ? null : match;
+				},
+
+				// Overrides response content-type header
+				overrideMimeType: function( type ) {
+					if ( !state ) {
+						s.mimeType = type;
+					}
+					return this;
+				},
+
+				// Cancel the request
+				abort: function( statusText ) {
+					statusText = statusText || strAbort;
+					if ( transport ) {
+						transport.abort( statusText );
+					}
+					done( 0, statusText );
+					return this;
+				}
+			};
+
+		// Callback for when everything is done
+		// It is defined here because jslint complains if it is declared
+		// at the end of the function (which would be more logical and readable)
+		function done( status, nativeStatusText, responses, headers ) {
+			var isSuccess, success, error, response, modified,
+				statusText = nativeStatusText;
+
+			// Called once
+			if ( state === 2 ) {
+				return;
+			}
+
+			// State is "done" now
+			state = 2;
+
+			// Clear timeout if it exists
+			if ( timeoutTimer ) {
+				clearTimeout( timeoutTimer );
+			}
+
+			// Dereference transport for early garbage collection
+			// (no matter how long the jqXHR object will be used)
+			transport = undefined;
+
+			// Cache response headers
+			responseHeadersString = headers || "";
+
+			// Set readyState
+			jqXHR.readyState = status > 0 ? 4 : 0;
+
+			// Get response data
+			if ( responses ) {
+				response = ajaxHandleResponses( s, jqXHR, responses );
+			}
+
+			// If successful, handle type chaining
+			if ( status >= 200 && status < 300 || status === 304 ) {
+
+				// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
+				if ( s.ifModified ) {
+
+					modified = jqXHR.getResponseHeader("Last-Modified");
+					if ( modified ) {
+						jQuery.lastModified[ ifModifiedKey ] = modified;
+					}
+					modified = jqXHR.getResponseHeader("Etag");
+					if ( modified ) {
+						jQuery.etag[ ifModifiedKey ] = modified;
+					}
+				}
+
+				// If not modified
+				if ( status === 304 ) {
+
+					statusText = "notmodified";
+					isSuccess = true;
+
+				// If we have data
+				} else {
+
+					isSuccess = ajaxConvert( s, response );
+					statusText = isSuccess.state;
+					success = isSuccess.data;
+					error = isSuccess.error;
+					isSuccess = !error;
+				}
+			} else {
+				// We extract error from statusText
+				// then normalize statusText and status for non-aborts
+				error = statusText;
+				if ( !statusText || status ) {
+					statusText = "error";
+					if ( status < 0 ) {
+						status = 0;
+					}
+				}
+			}
+
+			// Set data for the fake xhr object
+			jqXHR.status = status;
+			jqXHR.statusText = ( nativeStatusText || statusText ) + "";
+
+			// Success/Error
+			if ( isSuccess ) {
+				deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
+			} else {
+				deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
+			}
+
+			// Status-dependent callbacks
+			jqXHR.statusCode( statusCode );
+			statusCode = undefined;
+
+			if ( fireGlobals ) {
+				globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ),
+						[ jqXHR, s, isSuccess ? success : error ] );
+			}
+
+			// Complete
+			completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
+
+			if ( fireGlobals ) {
+				globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
+				// Handle the global AJAX counter
+				if ( !( --jQuery.active ) ) {
+					jQuery.event.trigger( "ajaxStop" );
+				}
+			}
+		}
+
+		// Attach deferreds
+		deferred.promise( jqXHR );
+		jqXHR.success = jqXHR.done;
+		jqXHR.error = jqXHR.fail;
+		jqXHR.complete = completeDeferred.add;
+
+		// Status-dependent callbacks
+		jqXHR.statusCode = function( map ) {
+			if ( map ) {
+				var tmp;
+				if ( state < 2 ) {
+					for ( tmp in map ) {
+						statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ];
+					}
+				} else {
+					tmp = map[ jqXHR.status ];
+					jqXHR.always( tmp );
+				}
+			}
+			return this;
+		};
+
+		// Remove hash character (#7531: and string promotion)
+		// Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
+		// We also use the url parameter if available
+		s.url = ( ( url || s.url ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
+
+		// Extract dataTypes list
+		s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().split( core_rspace );
+
+		// A cross-domain request is in order when we have a protocol:host:port mismatch
+		if ( s.crossDomain == null ) {
+			parts = rurl.exec( s.url.toLowerCase() ) || false;
+			s.crossDomain = parts && ( parts.join(":") + ( parts[ 3 ] ? "" : parts[ 1 ] === "http:" ? 80 : 443 ) ) !==
+				( ajaxLocParts.join(":") + ( ajaxLocParts[ 3 ] ? "" : ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) );
+		}
+
+		// Convert data if not already a string
+		if ( s.data && s.processData && typeof s.data !== "string" ) {
+			s.data = jQuery.param( s.data, s.traditional );
+		}
+
+		// Apply prefilters
+		inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
+
+		// If request was aborted inside a prefilter, stop there
+		if ( state === 2 ) {
+			return jqXHR;
+		}
+
+		// We can fire global events as of now if asked to
+		fireGlobals = s.global;
+
+		// Uppercase the type
+		s.type = s.type.toUpperCase();
+
+		// Determine if request has content
+		s.hasContent = !rnoContent.test( s.type );
+
+		// Watch for a new set of requests
+		if ( fireGlobals && jQuery.active++ === 0 ) {
+			jQuery.event.trigger( "ajaxStart" );
+		}
+
+		// More options handling for requests with no content
+		if ( !s.hasContent ) {
+
+			// If data is available, append data to url
+			if ( s.data ) {
+				s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data;
+				// #9682: remove data so that it's not used in an eventual retry
+				delete s.data;
+			}
+
+			// Get ifModifiedKey before adding the anti-cache parameter
+			ifModifiedKey = s.url;
+
+			// Add anti-cache in url if needed
+			if ( s.cache === false ) {
+
+				var ts = jQuery.now(),
+					// try replacing _= if it is there
+					ret = s.url.replace( rts, "$1_=" + ts );
+
+				// if nothing was replaced, add timestamp to the end
+				s.url = ret + ( ( ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" );
+			}
+		}
+
+		// Set the correct header, if data is being sent
+		if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
+			jqXHR.setRequestHeader( "Content-Type", s.contentType );
+		}
+
+		// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
+		if ( s.ifModified ) {
+			ifModifiedKey = ifModifiedKey || s.url;
+			if ( jQuery.lastModified[ ifModifiedKey ] ) {
+				jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ ifModifiedKey ] );
+			}
+			if ( jQuery.etag[ ifModifiedKey ] ) {
+				jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ ifModifiedKey ] );
+			}
+		}
+
+		// Set the Accepts header for the server, depending on the dataType
+		jqXHR.setRequestHeader(
+			"Accept",
+			s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
+				s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
+				s.accepts[ "*" ]
+		);
+
+		// Check for headers option
+		for ( i in s.headers ) {
+			jqXHR.setRequestHeader( i, s.headers[ i ] );
+		}
+
+		// Allow custom headers/mimetypes and early abort
+		if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
+				// Abort if not done already and return
+				return jqXHR.abort();
+
+		}
+
+		// aborting is no longer a cancellation
+		strAbort = "abort";
+
+		// Install callbacks on deferreds
+		for ( i in { success: 1, error: 1, complete: 1 } ) {
+			jqXHR[ i ]( s[ i ] );
+		}
+
+		// Get transport
+		transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
+
+		// If no transport, we auto-abort
+		if ( !transport ) {
+			done( -1, "No Transport" );
+		} else {
+			jqXHR.readyState = 1;
+			// Send global event
+			if ( fireGlobals ) {
+				globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
+			}
+			// Timeout
+			if ( s.async && s.timeout > 0 ) {
+				timeoutTimer = setTimeout( function(){
+					jqXHR.abort( "timeout" );
+				}, s.timeout );
+			}
+
+			try {
+				state = 1;
+				transport.send( requestHeaders, done );
+			} catch (e) {
+				// Propagate exception as error if not done
+				if ( state < 2 ) {
+					done( -1, e );
+				// Simply rethrow otherwise
+				} else {
+					throw e;
+				}
+			}
+		}
+
+		return jqXHR;
+	},
+
+	// Counter for holding the number of active queries
+	active: 0,
+
+	// Last-Modified header cache for next request
+	lastModified: {},
+	etag: {}
+
+});
+
+/* Handles responses to an ajax request:
+ * - sets all responseXXX fields accordingly
+ * - finds the right dataType (mediates between content-type and expected dataType)
+ * - returns the corresponding response
+ */
+function ajaxHandleResponses( s, jqXHR, responses ) {
+
+	var ct, type, finalDataType, firstDataType,
+		contents = s.contents,
+		dataTypes = s.dataTypes,
+		responseFields = s.responseFields;
+
+	// Fill responseXXX fields
+	for ( type in responseFields ) {
+		if ( type in responses ) {
+			jqXHR[ responseFields[type] ] = responses[ type ];
+		}
+	}
+
+	// Remove auto dataType and get content-type in the process
+	while( dataTypes[ 0 ] === "*" ) {
+		dataTypes.shift();
+		if ( ct === undefined ) {
+			ct = s.mimeType || jqXHR.getResponseHeader( "content-type" );
+		}
+	}
+
+	// Check if we're dealing with a known content-type
+	if ( ct ) {
+		for ( type in contents ) {
+			if ( contents[ type ] && contents[ type ].test( ct ) ) {
+				dataTypes.unshift( type );
+				break;
+			}
+		}
+	}
+
+	// Check to see if we have a response for the expected dataType
+	if ( dataTypes[ 0 ] in responses ) {
+		finalDataType = dataTypes[ 0 ];
+	} else {
+		// Try convertible dataTypes
+		for ( type in responses ) {
+			if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
+				finalDataType = type;
+				break;
+			}
+			if ( !firstDataType ) {
+				firstDataType = type;
+			}
+		}
+		// Or just use first one
+		finalDataType = finalDataType || firstDataType;
+	}
+
+	// If we found a dataType
+	// We add the dataType to the list if needed
+	// and return the corresponding response
+	if ( finalDataType ) {
+		if ( finalDataType !== dataTypes[ 0 ] ) {
+			dataTypes.unshift( finalDataType );
+		}
+		return responses[ finalDataType ];
+	}
+}
+
+// Chain conversions given the request and the original response
+function ajaxConvert( s, response ) {
+
+	var conv, conv2, current, tmp,
+		// Work with a copy of dataTypes in case we need to modify it for conversion
+		dataTypes = s.dataTypes.slice(),
+		prev = dataTypes[ 0 ],
+		converters = {},
+		i = 0;
+
+	// Apply the dataFilter if provided
+	if ( s.dataFilter ) {
+		response = s.dataFilter( response, s.dataType );
+	}
+
+	// Create converters map with lowercased keys
+	if ( dataTypes[ 1 ] ) {
+		for ( conv in s.converters ) {
+			converters[ conv.toLowerCase() ] = s.converters[ conv ];
+		}
+	}
+
+	// Convert to each sequential dataType, tolerating list modification
+	for ( ; (current = dataTypes[++i]); ) {
+
+		// There's only work to do if current dataType is non-auto
+		if ( current !== "*" ) {
+
+			// Convert response if prev dataType is non-auto and differs from current
+			if ( prev !== "*" && prev !== current ) {
+
+				// Seek a direct converter
+				conv = converters[ prev + " " + current ] || converters[ "* " + current ];
+
+				// If none found, seek a pair
+				if ( !conv ) {
+					for ( conv2 in converters ) {
+
+						// If conv2 outputs current
+						tmp = conv2.split(" ");
+						if ( tmp[ 1 ] === current ) {
+
+							// If prev can be converted to accepted input
+							conv = converters[ prev + " " + tmp[ 0 ] ] ||
+								converters[ "* " + tmp[ 0 ] ];
+							if ( conv ) {
+								// Condense equivalence converters
+								if ( conv === true ) {
+									conv = converters[ conv2 ];
+
+								// Otherwise, insert the intermediate dataType
+								} else if ( converters[ conv2 ] !== true ) {
+									current = tmp[ 0 ];
+									dataTypes.splice( i--, 0, current );
+								}
+
+								break;
+							}
+						}
+					}
+				}
+
+				// Apply converter (if not an equivalence)
+				if ( conv !== true ) {
+
+					// Unless errors are allowed to bubble, catch and return them
+					if ( conv && s["throws"] ) {
+						response = conv( response );
+					} else {
+						try {
+							response = conv( response );
+						} catch ( e ) {
+							return { state: "parsererror", error: conv ? e : "No conversion from " + prev + " to " + current };
+						}
+					}
+				}
+			}
+
+			// Update prev for next iteration
+			prev = current;
+		}
+	}
+
+	return { state: "success", data: response };
+}
+var oldCallbacks = [],
+	rquestion = /\?/,
+	rjsonp = /(=)\?(?=&|$)|\?\?/,
+	nonce = jQuery.now();
+
+// Default jsonp settings
+jQuery.ajaxSetup({
+	jsonp: "callback",
+	jsonpCallback: function() {
+		var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) );
+		this[ callback ] = true;
+		return callback;
+	}
+});
+
+// Detect, normalize options and install callbacks for jsonp requests
+jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
+
+	var callbackName, overwritten, responseContainer,
+		data = s.data,
+		url = s.url,
+		hasCallback = s.jsonp !== false,
+		replaceInUrl = hasCallback && rjsonp.test( url ),
+		replaceInData = hasCallback && !replaceInUrl && typeof data === "string" &&
+			!( s.contentType || "" ).indexOf("application/x-www-form-urlencoded") &&
+			rjsonp.test( data );
+
+	// Handle iff the expected data type is "jsonp" or we have a parameter to set
+	if ( s.dataTypes[ 0 ] === "jsonp" || replaceInUrl || replaceInData ) {
+
+		// Get callback name, remembering preexisting value associated with it
+		callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?
+			s.jsonpCallback() :
+			s.jsonpCallback;
+		overwritten = window[ callbackName ];
+
+		// Insert callback into url or form data
+		if ( replaceInUrl ) {
+			s.url = url.replace( rjsonp, "$1" + callbackName );
+		} else if ( replaceInData ) {
+			s.data = data.replace( rjsonp, "$1" + callbackName );
+		} else if ( hasCallback ) {
+			s.url += ( rquestion.test( url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
+		}
+
+		// Use data converter to retrieve json after script execution
+		s.converters["script json"] = function() {
+			if ( !responseContainer ) {
+				jQuery.error( callbackName + " was not called" );
+			}
+			return responseContainer[ 0 ];
+		};
+
+		// force json dataType
+		s.dataTypes[ 0 ] = "json";
+
+		// Install callback
+		window[ callbackName ] = function() {
+			responseContainer = arguments;
+		};
+
+		// Clean-up function (fires after converters)
+		jqXHR.always(function() {
+			// Restore preexisting value
+			window[ callbackName ] = overwritten;
+
+			// Save back as free
+			if ( s[ callbackName ] ) {
+				// make sure that re-using the options doesn't screw things around
+				s.jsonpCallback = originalSettings.jsonpCallback;
+
+				// save the callback name for future use
+				oldCallbacks.push( callbackName );
+			}
+
+			// Call if it was a function and we have a response
+			if ( responseContainer && jQuery.isFunction( overwritten ) ) {
+				overwritten( responseContainer[ 0 ] );
+			}
+
+			responseContainer = overwritten = undefined;
+		});
+
+		// Delegate to script
+		return "script";
+	}
+});
+// Install script dataType
+jQuery.ajaxSetup({
+	accepts: {
+		script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
+	},
+	contents: {
+		script: /javascript|ecmascript/
+	},
+	converters: {
+		"text script": function( text ) {
+			jQuery.globalEval( text );
+			return text;
+		}
+	}
+});
+
+// Handle cache's special case and global
+jQuery.ajaxPrefilter( "script", function( s ) {
+	if ( s.cache === undefined ) {
+		s.cache = false;
+	}
+	if ( s.crossDomain ) {
+		s.type = "GET";
+		s.global = false;
+	}
+});
+
+// Bind script tag hack transport
+jQuery.ajaxTransport( "script", function(s) {
+
+	// This transport only deals with cross domain requests
+	if ( s.crossDomain ) {
+
+		var script,
+			head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement;
+
+		return {
+
+			send: function( _, callback ) {
+
+				script = document.createElement( "script" );
+
+				script.async = "async";
+
+				if ( s.scriptCharset ) {
+					script.charset = s.scriptCharset;
+				}
+
+				script.src = s.url;
+
+				// Attach handlers for all browsers
+				script.onload = script.onreadystatechange = function( _, isAbort ) {
+
+					if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {
+
+						// Handle memory leak in IE
+						script.onload = script.onreadystatechange = null;
+
+						// Remove the script
+						if ( head && script.parentNode ) {
+							head.removeChild( script );
+						}
+
+						// Dereference the script
+						script = undefined;
+
+						// Callback if not abort
+						if ( !isAbort ) {
+							callback( 200, "success" );
+						}
+					}
+				};
+				// Use insertBefore instead of appendChild  to circumvent an IE6 bug.
+				// This arises when a base node is used (#2709 and #4378).
+				head.insertBefore( script, head.firstChild );
+			},
+
+			abort: function() {
+				if ( script ) {
+					script.onload( 0, 1 );
+				}
+			}
+		};
+	}
+});
+var xhrCallbacks,
+	// #5280: Internet Explorer will keep connections alive if we don't abort on unload
+	xhrOnUnloadAbort = window.ActiveXObject ? function() {
+		// Abort all pending requests
+		for ( var key in xhrCallbacks ) {
+			xhrCallbacks[ key ]( 0, 1 );
+		}
+	} : false,
+	xhrId = 0;
+
+// Functions to create xhrs
+function createStandardXHR() {
+	try {
+		return new window.XMLHttpRequest();
+	} catch( e ) {}
+}
+
+function createActiveXHR() {
+	try {
+		return new window.ActiveXObject( "Microsoft.XMLHTTP" );
+	} catch( e ) {}
+}
+
+// Create the request object
+// (This is still attached to ajaxSettings for backward compatibility)
+jQuery.ajaxSettings.xhr = window.ActiveXObject ?
+	/* Microsoft failed to properly
+	 * implement the XMLHttpRequest in IE7 (can't request local files),
+	 * so we use the ActiveXObject when it is available
+	 * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
+	 * we need a fallback.
+	 */
+	function() {
+		return !this.isLocal && createStandardXHR() || createActiveXHR();
+	} :
+	// For all other browsers, use the standard XMLHttpRequest object
+	createStandardXHR;
+
+// Determine support properties
+(function( xhr ) {
+	jQuery.extend( jQuery.support, {
+		ajax: !!xhr,
+		cors: !!xhr && ( "withCredentials" in xhr )
+	});
+})( jQuery.ajaxSettings.xhr() );
+
+// Create transport if the browser can provide an xhr
+if ( jQuery.support.ajax ) {
+
+	jQuery.ajaxTransport(function( s ) {
+		// Cross domain only allowed if supported through XMLHttpRequest
+		if ( !s.crossDomain || jQuery.support.cors ) {
+
+			var callback;
+
+			return {
+				send: function( headers, complete ) {
+
+					// Get a new xhr
+					var handle, i,
+						xhr = s.xhr();
+
+					// Open the socket
+					// Passing null username, generates a login popup on Opera (#2865)
+					if ( s.username ) {
+						xhr.open( s.type, s.url, s.async, s.username, s.password );
+					} else {
+						xhr.open( s.type, s.url, s.async );
+					}
+
+					// Apply custom fields if provided
+					if ( s.xhrFields ) {
+						for ( i in s.xhrFields ) {
+							xhr[ i ] = s.xhrFields[ i ];
+						}
+					}
+
+					// Override mime type if needed
+					if ( s.mimeType && xhr.overrideMimeType ) {
+						xhr.overrideMimeType( s.mimeType );
+					}
+
+					// X-Requested-With header
+					// For cross-domain requests, seeing as conditions for a preflight are
+					// akin to a jigsaw puzzle, we simply never set it to be sure.
+					// (it can always be set on a per-request basis or even using ajaxSetup)
+					// For same-domain requests, won't change header if already provided.
+					if ( !s.crossDomain && !headers["X-Requested-With"] ) {
+						headers[ "X-Requested-With" ] = "XMLHttpRequest";
+					}
+
+					// Need an extra try/catch for cross domain requests in Firefox 3
+					try {
+						for ( i in headers ) {
+							xhr.setRequestHeader( i, headers[ i ] );
+						}
+					} catch( _ ) {}
+
+					// Do send the request
+					// This may raise an exception which is actually
+					// handled in jQuery.ajax (so no try/catch here)
+					xhr.send( ( s.hasContent && s.data ) || null );
+
+					// Listener
+					callback = function( _, isAbort ) {
+
+						var status,
+							statusText,
+							responseHeaders,
+							responses,
+							xml;
+
+						// Firefox throws exceptions when accessing properties
+						// of an xhr when a network error occurred
+						// http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
+						try {
+
+							// Was never called and is aborted or complete
+							if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
+
+								// Only called once
+								callback = undefined;
+
+								// Do not keep as active anymore
+								if ( handle ) {
+									xhr.onreadystatechange = jQuery.noop;
+									if ( xhrOnUnloadAbort ) {
+										delete xhrCallbacks[ handle ];
+									}
+								}
+
+								// If it's an abort
+								if ( isAbort ) {
+									// Abort it manually if needed
+									if ( xhr.readyState !== 4 ) {
+										xhr.abort();
+									}
+								} else {
+									status = xhr.status;
+									responseHeaders = xhr.getAllResponseHeaders();
+									responses = {};
+									xml = xhr.responseXML;
+
+									// Construct response list
+									if ( xml && xml.documentElement /* #4958 */ ) {
+										responses.xml = xml;
+									}
+
+									// When requesting binary data, IE6-9 will throw an exception
+									// on any attempt to access responseText (#11426)
+									try {
+										responses.text = xhr.responseText;
+									} catch( _ ) {
+									}
+
+									// Firefox throws an exception when accessing
+									// statusText for faulty cross-domain requests
+									try {
+										statusText = xhr.statusText;
+									} catch( e ) {
+										// We normalize with Webkit giving an empty statusText
+										statusText = "";
+									}
+
+									// Filter status for non standard behaviors
+
+									// If the request is local and we have data: assume a success
+									// (success with no data won't get notified, that's the best we
+									// can do given current implementations)
+									if ( !status && s.isLocal && !s.crossDomain ) {
+										status = responses.text ? 200 : 404;
+									// IE - #1450: sometimes returns 1223 when it should be 204
+									} else if ( status === 1223 ) {
+										status = 204;
+									}
+								}
+							}
+						} catch( firefoxAccessException ) {
+							if ( !isAbort ) {
+								complete( -1, firefoxAccessException );
+							}
+						}
+
+						// Call complete if needed
+						if ( responses ) {
+							complete( status, statusText, responses, responseHeaders );
+						}
+					};
+
+					if ( !s.async ) {
+						// if we're in sync mode we fire the callback
+						callback();
+					} else if ( xhr.readyState === 4 ) {
+						// (IE6 & IE7) if it's in cache and has been
+						// retrieved directly we need to fire the callback
+						setTimeout( callback, 0 );
+					} else {
+						handle = ++xhrId;
+						if ( xhrOnUnloadAbort ) {
+							// Create the active xhrs callbacks list if needed
+							// and attach the unload handler
+							if ( !xhrCallbacks ) {
+								xhrCallbacks = {};
+								jQuery( window ).unload( xhrOnUnloadAbort );
+							}
+							// Add to list of active xhrs callbacks
+							xhrCallbacks[ handle ] = callback;
+						}
+						xhr.onreadystatechange = callback;
+					}
+				},
+
+				abort: function() {
+					if ( callback ) {
+						callback(0,1);
+					}
+				}
+			};
+		}
+	});
+}
+var fxNow, timerId,
+	rfxtypes = /^(?:toggle|show|hide)$/,
+	rfxnum = new RegExp( "^(?:([-+])=|)(" + core_pnum + ")([a-z%]*)$", "i" ),
+	rrun = /queueHooks$/,
+	animationPrefilters = [ defaultPrefilter ],
+	tweeners = {
+		"*": [function( prop, value ) {
+			var end, unit,
+				tween = this.createTween( prop, value ),
+				parts = rfxnum.exec( value ),
+				target = tween.cur(),
+				start = +target || 0,
+				scale = 1,
+				maxIterations = 20;
+
+			if ( parts ) {
+				end = +parts[2];
+				unit = parts[3] || ( jQuery.cssNumber[ prop ] ? "" : "px" );
+
+				// We need to compute starting value
+				if ( unit !== "px" && start ) {
+					// Iteratively approximate from a nonzero starting point
+					// Prefer the current property, because this process will be trivial if it uses the same units
+					// Fallback to end or a simple constant
+					start = jQuery.css( tween.elem, prop, true ) || end || 1;
+
+					do {
+						// If previous iteration zeroed out, double until we get *something*
+						// Use a string for doubling factor so we don't accidentally see scale as unchanged below
+						scale = scale || ".5";
+
+						// Adjust and apply
+						start = start / scale;
+						jQuery.style( tween.elem, prop, start + unit );
+
+					// Update scale, tolerating zero or NaN from tween.cur()
+					// And breaking the loop if scale is unchanged or perfect, or if we've just had enough
+					} while ( scale !== (scale = tween.cur() / target) && scale !== 1 && --maxIterations );
+				}
+
+				tween.unit = unit;
+				tween.start = start;
+				// If a +=/-= token was provided, we're doing a relative animation
+				tween.end = parts[1] ? start + ( parts[1] + 1 ) * end : end;
+			}
+			return tween;
+		}]
+	};
+
+// Animations created synchronously will run synchronously
+function createFxNow() {
+	setTimeout(function() {
+		fxNow = undefined;
+	}, 0 );
+	return ( fxNow = jQuery.now() );
+}
+
+function createTweens( animation, props ) {
+	jQuery.each( props, function( prop, value ) {
+		var collection = ( tweeners[ prop ] || [] ).concat( tweeners[ "*" ] ),
+			index = 0,
+			length = collection.length;
+		for ( ; index < length; index++ ) {
+			if ( collection[ index ].call( animation, prop, value ) ) {
+
+				// we're done with this property
+				return;
+			}
+		}
+	});
+}
+
+function Animation( elem, properties, options ) {
+	var result,
+		index = 0,
+		tweenerIndex = 0,
+		length = animationPrefilters.length,
+		deferred = jQuery.Deferred().always( function() {
+			// don't match elem in the :animated selector
+			delete tick.elem;
+		}),
+		tick = function() {
+			var currentTime = fxNow || createFxNow(),
+				remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
+				percent = 1 - ( remaining / animation.duration || 0 ),
+				index = 0,
+				length = animation.tweens.length;
+
+			for ( ; index < length ; index++ ) {
+				animation.tweens[ index ].run( percent );
+			}
+
+			deferred.notifyWith( elem, [ animation, percent, remaining ]);
+
+			if ( percent < 1 && length ) {
+				return remaining;
+			} else {
+				deferred.resolveWith( elem, [ animation ] );
+				return false;
+			}
+		},
+		animation = deferred.promise({
+			elem: elem,
+			props: jQuery.extend( {}, properties ),
+			opts: jQuery.extend( true, { specialEasing: {} }, options ),
+			originalProperties: properties,
+			originalOptions: options,
+			startTime: fxNow || createFxNow(),
+			duration: options.duration,
+			tweens: [],
+			createTween: function( prop, end, easing ) {
+				var tween = jQuery.Tween( elem, animation.opts, prop, end,
+						animation.opts.specialEasing[ prop ] || animation.opts.easing );
+				animation.tweens.push( tween );
+				return tween;
+			},
+			stop: function( gotoEnd ) {
+				var index = 0,
+					// if we are going to the end, we want to run all the tweens
+					// otherwise we skip this part
+					length = gotoEnd ? animation.tweens.length : 0;
+
+				for ( ; index < length ; index++ ) {
+					animation.tweens[ index ].run( 1 );
+				}
+
+				// resolve when we played the last frame
+				// otherwise, reject
+				if ( gotoEnd ) {
+					deferred.resolveWith( elem, [ animation, gotoEnd ] );
+				} else {
+					deferred.rejectWith( elem, [ animation, gotoEnd ] );
+				}
+				return this;
+			}
+		}),
+		props = animation.props;
+
+	propFilter( props, animation.opts.specialEasing );
+
+	for ( ; index < length ; index++ ) {
+		result = animationPrefilters[ index ].call( animation, elem, props, animation.opts );
+		if ( result ) {
+			return result;
+		}
+	}
+
+	createTweens( animation, props );
+
+	if ( jQuery.isFunction( animation.opts.start ) ) {
+		animation.opts.start.call( elem, animation );
+	}
+
+	jQuery.fx.timer(
+		jQuery.extend( tick, {
+			anim: animation,
+			queue: animation.opts.queue,
+			elem: elem
+		})
+	);
+
+	// attach callbacks from options
+	return animation.progress( animation.opts.progress )
+		.done( animation.opts.done, animation.opts.complete )
+		.fail( animation.opts.fail )
+		.always( animation.opts.always );
+}
+
+function propFilter( props, specialEasing ) {
+	var index, name, easing, value, hooks;
+
+	// camelCase, specialEasing and expand cssHook pass
+	for ( index in props ) {
+		name = jQuery.camelCase( index );
+		easing = specialEasing[ name ];
+		value = props[ index ];
+		if ( jQuery.isArray( value ) ) {
+			easing = value[ 1 ];
+			value = props[ index ] = value[ 0 ];
+		}
+
+		if ( index !== name ) {
+			props[ name ] = value;
+			delete props[ index ];
+		}
+
+		hooks = jQuery.cssHooks[ name ];
+		if ( hooks && "expand" in hooks ) {
+			value = hooks.expand( value );
+			delete props[ name ];
+
+			// not quite $.extend, this wont overwrite keys already present.
+			// also - reusing 'index' from above because we have the correct "name"
+			for ( index in value ) {
+				if ( !( index in props ) ) {
+					props[ index ] = value[ index ];
+					specialEasing[ index ] = easing;
+				}
+			}
+		} else {
+			specialEasing[ name ] = easing;
+		}
+	}
+}
+
+jQuery.Animation = jQuery.extend( Animation, {
+
+	tweener: function( props, callback ) {
+		if ( jQuery.isFunction( props ) ) {
+			callback = props;
+			props = [ "*" ];
+		} else {
+			props = props.split(" ");
+		}
+
+		var prop,
+			index = 0,
+			length = props.length;
+
+		for ( ; index < length ; index++ ) {
+			prop = props[ index ];
+			tweeners[ prop ] = tweeners[ prop ] || [];
+			tweeners[ prop ].unshift( callback );
+		}
+	},
+
+	prefilter: function( callback, prepend ) {
+		if ( prepend ) {
+			animationPrefilters.unshift( callback );
+		} else {
+			animationPrefilters.push( callback );
+		}
+	}
+});
+
+function defaultPrefilter( elem, props, opts ) {
+	var index, prop, value, length, dataShow, tween, hooks, oldfire,
+		anim = this,
+		style = elem.style,
+		orig = {},
+		handled = [],
+		hidden = elem.nodeType && isHidden( elem );
+
+	// handle queue: false promises
+	if ( !opts.queue ) {
+		hooks = jQuery._queueHooks( elem, "fx" );
+		if ( hooks.unqueued == null ) {
+			hooks.unqueued = 0;
+			oldfire = hooks.empty.fire;
+			hooks.empty.fire = function() {
+				if ( !hooks.unqueued ) {
+					oldfire();
+				}
+			};
+		}
+		hooks.unqueued++;
+
+		anim.always(function() {
+			// doing this makes sure that the complete handler will be called
+			// before this completes
+			anim.always(function() {
+				hooks.unqueued--;
+				if ( !jQuery.queue( elem, "fx" ).length ) {
+					hooks.empty.fire();
+				}
+			});
+		});
+	}
+
+	// height/width overflow pass
+	if ( elem.nodeType === 1 && ( "height" in props || "width" in props ) ) {
+		// Make sure that nothing sneaks out
+		// Record all 3 overflow attributes because IE does not
+		// change the overflow attribute when overflowX and
+		// overflowY are set to the same value
+		opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
+
+		// Set display property to inline-block for height/width
+		// animations on inline elements that are having width/height animated
+		if ( jQuery.css( elem, "display" ) === "inline" &&
+				jQuery.css( elem, "float" ) === "none" ) {
+
+			// inline-level elements accept inline-block;
+			// block-level elements need to be inline with layout
+			if ( !jQuery.support.inlineBlockNeedsLayout || css_defaultDisplay( elem.nodeName ) === "inline" ) {
+				style.display = "inline-block";
+
+			} else {
+				style.zoom = 1;
+			}
+		}
+	}
+
+	if ( opts.overflow ) {
+		style.overflow = "hidden";
+		if ( !jQuery.support.shrinkWrapBlocks ) {
+			anim.done(function() {
+				style.overflow = opts.overflow[ 0 ];
+				style.overflowX = opts.overflow[ 1 ];
+				style.overflowY = opts.overflow[ 2 ];
+			});
+		}
+	}
+
+
+	// show/hide pass
+	for ( index in props ) {
+		value = props[ index ];
+		if ( rfxtypes.exec( value ) ) {
+			delete props[ index ];
+			if ( value === ( hidden ? "hide" : "show" ) ) {
+				continue;
+			}
+			handled.push( index );
+		}
+	}
+
+	length = handled.length;
+	if ( length ) {
+		dataShow = jQuery._data( elem, "fxshow" ) || jQuery._data( elem, "fxshow", {} );
+		if ( hidden ) {
+			jQuery( elem ).show();
+		} else {
+			anim.done(function() {
+				jQuery( elem ).hide();
+			});
+		}
+		anim.done(function() {
+			var prop;
+			jQuery.removeData( elem, "fxshow", true );
+			for ( prop in orig ) {
+				jQuery.style( elem, prop, orig[ prop ] );
+			}
+		});
+		for ( index = 0 ; index < length ; index++ ) {
+			prop = handled[ index ];
+			tween = anim.createTween( prop, hidden ? dataShow[ prop ] : 0 );
+			orig[ prop ] = dataShow[ prop ] || jQuery.style( elem, prop );
+
+			if ( !( prop in dataShow ) ) {
+				dataShow[ prop ] = tween.start;
+				if ( hidden ) {
+					tween.end = tween.start;
+					tween.start = prop === "width" || prop === "height" ? 1 : 0;
+				}
+			}
+		}
+	}
+}
+
+function Tween( elem, options, prop, end, easing ) {
+	return new Tween.prototype.init( elem, options, prop, end, easing );
+}
+jQuery.Tween = Tween;
+
+Tween.prototype = {
+	constructor: Tween,
+	init: function( elem, options, prop, end, easing, unit ) {
+		this.elem = elem;
+		this.prop = prop;
+		this.easing = easing || "swing";
+		this.options = options;
+		this.start = this.now = this.cur();
+		this.end = end;
+		this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
+	},
+	cur: function() {
+		var hooks = Tween.propHooks[ this.prop ];
+
+		return hooks && hooks.get ?
+			hooks.get( this ) :
+			Tween.propHooks._default.get( this );
+	},
+	run: function( percent ) {
+		var eased,
+			hooks = Tween.propHooks[ this.prop ];
+
+		if ( this.options.duration ) {
+			this.pos = eased = jQuery.easing[ this.easing ](
+				percent, this.options.duration * percent, 0, 1, this.options.duration
+			);
+		} else {
+			this.pos = eased = percent;
+		}
+		this.now = ( this.end - this.start ) * eased + this.start;
+
+		if ( this.options.step ) {
+			this.options.step.call( this.elem, this.now, this );
+		}
+
+		if ( hooks && hooks.set ) {
+			hooks.set( this );
+		} else {
+			Tween.propHooks._default.set( this );
+		}
+		return this;
+	}
+};
+
+Tween.prototype.init.prototype = Tween.prototype;
+
+Tween.propHooks = {
+	_default: {
+		get: function( tween ) {
+			var result;
+
+			if ( tween.elem[ tween.prop ] != null &&
+				(!tween.elem.style || tween.elem.style[ tween.prop ] == null) ) {
+				return tween.elem[ tween.prop ];
+			}
+
+			// passing any value as a 4th parameter to .css will automatically
+			// attempt a parseFloat and fallback to a string if the parse fails
+			// so, simple values such as "10px" are parsed to Float.
+			// complex values such as "rotate(1rad)" are returned as is.
+			result = jQuery.css( tween.elem, tween.prop, false, "" );
+			// Empty strings, null, undefined and "auto" are converted to 0.
+			return !result || result === "auto" ? 0 : result;
+		},
+		set: function( tween ) {
+			// use step hook for back compat - use cssHook if its there - use .style if its
+			// available and use plain properties where available
+			if ( jQuery.fx.step[ tween.prop ] ) {
+				jQuery.fx.step[ tween.prop ]( tween );
+			} else if ( tween.elem.style && ( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null || jQuery.cssHooks[ tween.prop ] ) ) {
+				jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
+			} else {
+				tween.elem[ tween.prop ] = tween.now;
+			}
+		}
+	}
+};
+
+// Remove in 2.0 - this supports IE8's panic based approach
+// to setting things on disconnected nodes
+
+Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
+	set: function( tween ) {
+		if ( tween.elem.nodeType && tween.elem.parentNode ) {
+			tween.elem[ tween.prop ] = tween.now;
+		}
+	}
+};
+
+jQuery.each([ "toggle", "show", "hide" ], function( i, name ) {
+	var cssFn = jQuery.fn[ name ];
+	jQuery.fn[ name ] = function( speed, easing, callback ) {
+		return speed == null || typeof speed === "boolean" ||
+			// special check for .toggle( handler, handler, ... )
+			( !i && jQuery.isFunction( speed ) && jQuery.isFunction( easing ) ) ?
+			cssFn.apply( this, arguments ) :
+			this.animate( genFx( name, true ), speed, easing, callback );
+	};
+});
+
+jQuery.fn.extend({
+	fadeTo: function( speed, to, easing, callback ) {
+
+		// show any hidden elements after setting opacity to 0
+		return this.filter( isHidden ).css( "opacity", 0 ).show()
+
+			// animate to the value specified
+			.end().animate({ opacity: to }, speed, easing, callback );
+	},
+	animate: function( prop, speed, easing, callback ) {
+		var empty = jQuery.isEmptyObject( prop ),
+			optall = jQuery.speed( speed, easing, callback ),
+			doAnimation = function() {
+				// Operate on a copy of prop so per-property easing won't be lost
+				var anim = Animation( this, jQuery.extend( {}, prop ), optall );
+
+				// Empty animations resolve immediately
+				if ( empty ) {
+					anim.stop( true );
+				}
+			};
+
+		return empty || optall.queue === false ?
+			this.each( doAnimation ) :
+			this.queue( optall.queue, doAnimation );
+	},
+	stop: function( type, clearQueue, gotoEnd ) {
+		var stopQueue = function( hooks ) {
+			var stop = hooks.stop;
+			delete hooks.stop;
+			stop( gotoEnd );
+		};
+
+		if ( typeof type !== "string" ) {
+			gotoEnd = clearQueue;
+			clearQueue = type;
+			type = undefined;
+		}
+		if ( clearQueue && type !== false ) {
+			this.queue( type || "fx", [] );
+		}
+
+		return this.each(function() {
+			var dequeue = true,
+				index = type != null && type + "queueHooks",
+				timers = jQuery.timers,
+				data = jQuery._data( this );
+
+			if ( index ) {
+				if ( data[ index ] && data[ index ].stop ) {
+					stopQueue( data[ index ] );
+				}
+			} else {
+				for ( index in data ) {
+					if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
+						stopQueue( data[ index ] );
+					}
+				}
+			}
+
+			for ( index = timers.length; index--; ) {
+				if ( timers[ index ].elem === this && (type == null || timers[ index ].queue === type) ) {
+					timers[ index ].anim.stop( gotoEnd );
+					dequeue = false;
+					timers.splice( index, 1 );
+				}
+			}
+
+			// start the next in the queue if the last step wasn't forced
+			// timers currently will call their complete callbacks, which will dequeue
+			// but only if they were gotoEnd
+			if ( dequeue || !gotoEnd ) {
+				jQuery.dequeue( this, type );
+			}
+		});
+	}
+});
+
+// Generate parameters to create a standard animation
+function genFx( type, includeWidth ) {
+	var which,
+		attrs = { height: type },
+		i = 0;
+
+	// if we include width, step value is 1 to do all cssExpand values,
+	// if we don't include width, step value is 2 to skip over Left and Right
+	includeWidth = includeWidth? 1 : 0;
+	for( ; i < 4 ; i += 2 - includeWidth ) {
+		which = cssExpand[ i ];
+		attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
+	}
+
+	if ( includeWidth ) {
+		attrs.opacity = attrs.width = type;
+	}
+
+	return attrs;
+}
+
+// Generate shortcuts for custom animations
+jQuery.each({
+	slideDown: genFx("show"),
+	slideUp: genFx("hide"),
+	slideToggle: genFx("toggle"),
+	fadeIn: { opacity: "show" },
+	fadeOut: { opacity: "hide" },
+	fadeToggle: { opacity: "toggle" }
+}, function( name, props ) {
+	jQuery.fn[ name ] = function( speed, easing, callback ) {
+		return this.animate( props, speed, easing, callback );
+	};
+});
+
+jQuery.speed = function( speed, easing, fn ) {
+	var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
+		complete: fn || !fn && easing ||
+			jQuery.isFunction( speed ) && speed,
+		duration: speed,
+		easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
+	};
+
+	opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
+		opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;
+
+	// normalize opt.queue - true/undefined/null -> "fx"
+	if ( opt.queue == null || opt.queue === true ) {
+		opt.queue = "fx";
+	}
+
+	// Queueing
+	opt.old = opt.complete;
+
+	opt.complete = function() {
+		if ( jQuery.isFunction( opt.old ) ) {
+			opt.old.call( this );
+		}
+
+		if ( opt.queue ) {
+			jQuery.dequeue( this, opt.queue );
+		}
+	};
+
+	return opt;
+};
+
+jQuery.easing = {
+	linear: function( p ) {
+		return p;
+	},
+	swing: function( p ) {
+		return 0.5 - Math.cos( p*Math.PI ) / 2;
+	}
+};
+
+jQuery.timers = [];
+jQuery.fx = Tween.prototype.init;
+jQuery.fx.tick = function() {
+	var timer,
+		timers = jQuery.timers,
+		i = 0;
+
+	for ( ; i < timers.length; i++ ) {
+		timer = timers[ i ];
+		// Checks the timer has not already been removed
+		if ( !timer() && timers[ i ] === timer ) {
+			timers.splice( i--, 1 );
+		}
+	}
+
+	if ( !timers.length ) {
+		jQuery.fx.stop();
+	}
+};
+
+jQuery.fx.timer = function( timer ) {
+	if ( timer() && jQuery.timers.push( timer ) && !timerId ) {
+		timerId = setInterval( jQuery.fx.tick, jQuery.fx.interval );
+	}
+};
+
+jQuery.fx.interval = 13;
+
+jQuery.fx.stop = function() {
+	clearInterval( timerId );
+	timerId = null;
+};
+
+jQuery.fx.speeds = {
+	slow: 600,
+	fast: 200,
+	// Default speed
+	_default: 400
+};
+
+// Back Compat <1.8 extension point
+jQuery.fx.step = {};
+
+if ( jQuery.expr && jQuery.expr.filters ) {
+	jQuery.expr.filters.animated = function( elem ) {
+		return jQuery.grep(jQuery.timers, function( fn ) {
+			return elem === fn.elem;
+		}).length;
+	};
+}
+var rroot = /^(?:body|html)$/i;
+
+jQuery.fn.offset = function( options ) {
+	if ( arguments.length ) {
+		return options === undefined ?
+			this :
+			this.each(function( i ) {
+				jQuery.offset.setOffset( this, options, i );
+			});
+	}
+
+	var docElem, body, win, clientTop, clientLeft, scrollTop, scrollLeft,
+		box = { top: 0, left: 0 },
+		elem = this[ 0 ],
+		doc = elem && elem.ownerDocument;
+
+	if ( !doc ) {
+		return;
+	}
+
+	if ( (body = doc.body) === elem ) {
+		return jQuery.offset.bodyOffset( elem );
+	}
+
+	docElem = doc.documentElement;
+
+	// Make sure it's not a disconnected DOM node
+	if ( !jQuery.contains( docElem, elem ) ) {
+		return box;
+	}
+
+	// If we don't have gBCR, just use 0,0 rather than error
+	// BlackBerry 5, iOS 3 (original iPhone)
+	if ( typeof elem.getBoundingClientRect !== "undefined" ) {
+		box = elem.getBoundingClientRect();
+	}
+	win = getWindow( doc );
+	clientTop  = docElem.clientTop  || body.clientTop  || 0;
+	clientLeft = docElem.clientLeft || body.clientLeft || 0;
+	scrollTop  = win.pageYOffset || docElem.scrollTop;
+	scrollLeft = win.pageXOffset || docElem.scrollLeft;
+	return {
+		top: box.top  + scrollTop  - clientTop,
+		left: box.left + scrollLeft - clientLeft
+	};
+};
+
+jQuery.offset = {
+
+	bodyOffset: function( body ) {
+		var top = body.offsetTop,
+			left = body.offsetLeft;
+
+		if ( jQuery.support.doesNotIncludeMarginInBodyOffset ) {
+			top  += parseFloat( jQuery.css(body, "marginTop") ) || 0;
+			left += parseFloat( jQuery.css(body, "marginLeft") ) || 0;
+		}
+
+		return { top: top, left: left };
+	},
+
+	setOffset: function( elem, options, i ) {
+		var position = jQuery.css( elem, "position" );
+
+		// set position first, in-case top/left are set even on static elem
+		if ( position === "static" ) {
+			elem.style.position = "relative";
+		}
+
+		var curElem = jQuery( elem ),
+			curOffset = curElem.offset(),
+			curCSSTop = jQuery.css( elem, "top" ),
+			curCSSLeft = jQuery.css( elem, "left" ),
+			calculatePosition = ( position === "absolute" || position === "fixed" ) && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
+			props = {}, curPosition = {}, curTop, curLeft;
+
+		// need to be able to calculate position if either top or left is auto and position is either absolute or fixed
+		if ( calculatePosition ) {
+			curPosition = curElem.position();
+			curTop = curPosition.top;
+			curLeft = curPosition.left;
+		} else {
+			curTop = parseFloat( curCSSTop ) || 0;
+			curLeft = parseFloat( curCSSLeft ) || 0;
+		}
+
+		if ( jQuery.isFunction( options ) ) {
+			options = options.call( elem, i, curOffset );
+		}
+
+		if ( options.top != null ) {
+			props.top = ( options.top - curOffset.top ) + curTop;
+		}
+		if ( options.left != null ) {
+			props.left = ( options.left - curOffset.left ) + curLeft;
+		}
+
+		if ( "using" in options ) {
+			options.using.call( elem, props );
+		} else {
+			curElem.css( props );
+		}
+	}
+};
+
+
+jQuery.fn.extend({
+
+	position: function() {
+		if ( !this[0] ) {
+			return;
+		}
+
+		var elem = this[0],
+
+		// Get *real* offsetParent
+		offsetParent = this.offsetParent(),
+
+		// Get correct offsets
+		offset       = this.offset(),
+		parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
+
+		// Subtract element margins
+		// note: when an element has margin: auto the offsetLeft and marginLeft
+		// are the same in Safari causing offset.left to incorrectly be 0
+		offset.top  -= parseFloat( jQuery.css(elem, "marginTop") ) || 0;
+		offset.left -= parseFloat( jQuery.css(elem, "marginLeft") ) || 0;
+
+		// Add offsetParent borders
+		parentOffset.top  += parseFloat( jQuery.css(offsetParent[0], "borderTopWidth") ) || 0;
+		parentOffset.left += parseFloat( jQuery.css(offsetParent[0], "borderLeftWidth") ) || 0;
+
+		// Subtract the two offsets
+		return {
+			top:  offset.top  - parentOffset.top,
+			left: offset.left - parentOffset.left
+		};
+	},
+
+	offsetParent: function() {
+		return this.map(function() {
+			var offsetParent = this.offsetParent || document.body;
+			while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
+				offsetParent = offsetParent.offsetParent;
+			}
+			return offsetParent || document.body;
+		});
+	}
+});
+
+
+// Create scrollLeft and scrollTop methods
+jQuery.each( {scrollLeft: "pageXOffset", scrollTop: "pageYOffset"}, function( method, prop ) {
+	var top = /Y/.test( prop );
+
+	jQuery.fn[ method ] = function( val ) {
+		return jQuery.access( this, function( elem, method, val ) {
+			var win = getWindow( elem );
+
+			if ( val === undefined ) {
+				return win ? (prop in win) ? win[ prop ] :
+					win.document.documentElement[ method ] :
+					elem[ method ];
+			}
+
+			if ( win ) {
+				win.scrollTo(
+					!top ? val : jQuery( win ).scrollLeft(),
+					 top ? val : jQuery( win ).scrollTop()
+				);
+
+			} else {
+				elem[ method ] = val;
+			}
+		}, method, val, arguments.length, null );
+	};
+});
+
+function getWindow( elem ) {
+	return jQuery.isWindow( elem ) ?
+		elem :
+		elem.nodeType === 9 ?
+			elem.defaultView || elem.parentWindow :
+			false;
+}
+// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
+jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
+	jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name }, function( defaultExtra, funcName ) {
+		// margin is only for outerHeight, outerWidth
+		jQuery.fn[ funcName ] = function( margin, value ) {
+			var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
+				extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
+
+			return jQuery.access( this, function( elem, type, value ) {
+				var doc;
+
+				if ( jQuery.isWindow( elem ) ) {
+					// As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there
+					// isn't a whole lot we can do. See pull request at this URL for discussion:
+					// https://github.com/jquery/jquery/pull/764
+					return elem.document.documentElement[ "client" + name ];
+				}
+
+				// Get document width or height
+				if ( elem.nodeType === 9 ) {
+					doc = elem.documentElement;
+
+					// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height], whichever is greatest
+					// unfortunately, this causes bug #3838 in IE6/8 only, but there is currently no good, small way to fix it.
+					return Math.max(
+						elem.body[ "scroll" + name ], doc[ "scroll" + name ],
+						elem.body[ "offset" + name ], doc[ "offset" + name ],
+						doc[ "client" + name ]
+					);
+				}
+
+				return value === undefined ?
+					// Get width or height on the element, requesting but not forcing parseFloat
+					jQuery.css( elem, type, value, extra ) :
+
+					// Set width or height on the element
+					jQuery.style( elem, type, value, extra );
+			}, type, chainable ? margin : undefined, chainable, null );
+		};
+	});
+});
+// Expose jQuery to the global object
+window.jQuery = window.$ = jQuery;
+
+// Expose jQuery as an AMD module, but only for AMD loaders that
+// understand the issues with loading multiple versions of jQuery
+// in a page that all might call define(). The loader will indicate
+// they have special allowances for multiple jQuery versions by
+// specifying define.amd.jQuery = true. Register as a named module,
+// since jQuery can be concatenated with other files that may use define,
+// but not use a proper concatenation script that understands anonymous
+// AMD modules. A named AMD is safest and most robust way to register.
+// Lowercase jquery is used because AMD module names are derived from
+// file names, and jQuery is normally delivered in a lowercase file name.
+// Do this after creating the global so that if an AMD module wants to call
+// noConflict to hide this version of jQuery, it will work.
+if ( typeof define === "function" && define.amd && define.amd.jQuery ) {
+	define( "jquery", [], function () { return jQuery; } );
+}
+
+})( window );
diff --git a/test/jquery-1.8.2.min.js b/test/jquery-1.8.2.min.js
new file mode 100644
index 0000000..bc3fbc8
--- /dev/null
+++ b/test/jquery-1.8.2.min.js
@@ -0,0 +1,2 @@
+/*! jQuery v1.8.2 jquery.com | jquery.org/license */
+(function(a,b){function G(a){var b=F[a]={};return p.each(a.split(s),function(a,c){b[c]=!0}),b}function J(a,c,d){if(d===b&&a.nodeType===1){var e="data-"+c.replace(I,"-$1").toLowerCase();d=a.getAttribute(e);if(typeof d=="string"){try{d=d==="true"?!0:d==="false"?!1:d==="null"?null:+d+""===d?+d:H.test(d)?p.parseJSON(d):d}catch(f){}p.data(a,c,d)}else d=b}return d}function K(a){var b;for(b in a){if(b==="data"&&p.isEmptyObject(a[b]))continue;if(b!=="toJSON")return!1}return!0}function ba(){return!1}function bb(){return!0}function bh(a){return!a||!a.parentNode||a.parentNode.nodeType===11}function bi(a,b){do a=a[b];while(a&&a.nodeType!==1);return a}function bj(a,b,c){b=b||0;if(p.isFunction(b))return p.grep(a,function(a,d){var e=!!b.call(a,d,a);return e===c});if(b.nodeType)return p.grep(a,function(a,d){return a===b===c});if(typeof b=="string"){var d=p.grep(a,function(a){return a.nodeType===1});if(be.test(b))return p.filter(b,d,!c);b=p.filter(b,d)}return p.grep(a,function(a,d){return p.inArray(a,b)>=0===c})}function bk(a){var b=bl.split("|"),c=a.createDocumentFragment();if(c.createElement)while(b.length)c.createElement(b.pop());return c}function bC(a,b){return a.getElementsByTagName(b)[0]||a.appendChild(a.ownerDocument.createElement(b))}function bD(a,b){if(b.nodeType!==1||!p.hasData(a))return;var c,d,e,f=p._data(a),g=p._data(b,f),h=f.events;if(h){delete g.handle,g.events={};for(c in h)for(d=0,e=h[c].length;d<e;d++)p.event.add(b,c,h[c][d])}g.data&&(g.data=p.extend({},g.data))}function bE(a,b){var c;if(b.nodeType!==1)return;b.clearAttributes&&b.clearAttributes(),b.mergeAttributes&&b.mergeAttributes(a),c=b.nodeName.toLowerCase(),c==="object"?(b.parentNode&&(b.outerHTML=a.outerHTML),p.support.html5Clone&&a.innerHTML&&!p.trim(b.innerHTML)&&(b.innerHTML=a.innerHTML)):c==="input"&&bv.test(a.type)?(b.defaultChecked=b.checked=a.checked,b.value!==a.value&&(b.value=a.value)):c==="option"?b.selected=a.defaultSelected:c==="input"||c==="textarea"?b.defaultValue=a.defaultValue:c==="script"&&b.text!==a.text&&(b.text=a.text),b.removeAttribute(p.expando)}function bF(a){return typeof a.getElementsByTagName!="undefined"?a.getElementsByTagName("*"):typeof a.querySelectorAll!="undefined"?a.querySelectorAll("*"):[]}function bG(a){bv.test(a.type)&&(a.defaultChecked=a.checked)}function bY(a,b){if(b in a)return b;var c=b.charAt(0).toUpperCase()+b.slice(1),d=b,e=bW.length;while(e--){b=bW[e]+c;if(b in a)return b}return d}function bZ(a,b){return a=b||a,p.css(a,"display")==="none"||!p.contains(a.ownerDocument,a)}function b$(a,b){var c,d,e=[],f=0,g=a.length;for(;f<g;f++){c=a[f];if(!c.style)continue;e[f]=p._data(c,"olddisplay"),b?(!e[f]&&c.style.display==="none"&&(c.style.display=""),c.style.display===""&&bZ(c)&&(e[f]=p._data(c,"olddisplay",cc(c.nodeName)))):(d=bH(c,"display"),!e[f]&&d!=="none"&&p._data(c,"olddisplay",d))}for(f=0;f<g;f++){c=a[f];if(!c.style)continue;if(!b||c.style.display==="none"||c.style.display==="")c.style.display=b?e[f]||"":"none"}return a}function b_(a,b,c){var d=bP.exec(b);return d?Math.max(0,d[1]-(c||0))+(d[2]||"px"):b}function ca(a,b,c,d){var e=c===(d?"border":"content")?4:b==="width"?1:0,f=0;for(;e<4;e+=2)c==="margin"&&(f+=p.css(a,c+bV[e],!0)),d?(c==="content"&&(f-=parseFloat(bH(a,"padding"+bV[e]))||0),c!=="margin"&&(f-=parseFloat(bH(a,"border"+bV[e]+"Width"))||0)):(f+=parseFloat(bH(a,"padding"+bV[e]))||0,c!=="padding"&&(f+=parseFloat(bH(a,"border"+bV[e]+"Width"))||0));return f}function cb(a,b,c){var d=b==="width"?a.offsetWidth:a.offsetHeight,e=!0,f=p.support.boxSizing&&p.css(a,"boxSizing")==="border-box";if(d<=0||d==null){d=bH(a,b);if(d<0||d==null)d=a.style[b];if(bQ.test(d))return d;e=f&&(p.support.boxSizingReliable||d===a.style[b]),d=parseFloat(d)||0}return d+ca(a,b,c||(f?"border":"content"),e)+"px"}function cc(a){if(bS[a])return bS[a];var b=p("<"+a+">").appendTo(e.body),c=b.css("display");b.remove();if(c==="none"||c===""){bI=e.body.appendChild(bI||p.extend(e.createElement("iframe"),{frameBorder:0,width:0,height:0}));if(!bJ||!bI.createElement)bJ=(bI.contentWindow||bI.contentDocument).document,bJ.write("<!doctype html><html><body>"),bJ.close();b=bJ.body.appendChild(bJ.createElement(a)),c=bH(b,"display"),e.body.removeChild(bI)}return bS[a]=c,c}function ci(a,b,c,d){var e;if(p.isArray(b))p.each(b,function(b,e){c||ce.test(a)?d(a,e):ci(a+"["+(typeof e=="object"?b:"")+"]",e,c,d)});else if(!c&&p.type(b)==="object")for(e in b)ci(a+"["+e+"]",b[e],c,d);else d(a,b)}function cz(a){return function(b,c){typeof b!="string"&&(c=b,b="*");var d,e,f,g=b.toLowerCase().split(s),h=0,i=g.length;if(p.isFunction(c))for(;h<i;h++)d=g[h],f=/^\+/.test(d),f&&(d=d.substr(1)||"*"),e=a[d]=a[d]||[],e[f?"unshift":"push"](c)}}function cA(a,c,d,e,f,g){f=f||c.dataTypes[0],g=g||{},g[f]=!0;var h,i=a[f],j=0,k=i?i.length:0,l=a===cv;for(;j<k&&(l||!h);j++)h=i[j](c,d,e),typeof h=="string"&&(!l||g[h]?h=b:(c.dataTypes.unshift(h),h=cA(a,c,d,e,h,g)));return(l||!h)&&!g["*"]&&(h=cA(a,c,d,e,"*",g)),h}function cB(a,c){var d,e,f=p.ajaxSettings.flatOptions||{};for(d in c)c[d]!==b&&((f[d]?a:e||(e={}))[d]=c[d]);e&&p.extend(!0,a,e)}function cC(a,c,d){var e,f,g,h,i=a.contents,j=a.dataTypes,k=a.responseFields;for(f in k)f in d&&(c[k[f]]=d[f]);while(j[0]==="*")j.shift(),e===b&&(e=a.mimeType||c.getResponseHeader("content-type"));if(e)for(f in i)if(i[f]&&i[f].test(e)){j.unshift(f);break}if(j[0]in d)g=j[0];else{for(f in d){if(!j[0]||a.converters[f+" "+j[0]]){g=f;break}h||(h=f)}g=g||h}if(g)return g!==j[0]&&j.unshift(g),d[g]}function cD(a,b){var c,d,e,f,g=a.dataTypes.slice(),h=g[0],i={},j=0;a.dataFilter&&(b=a.dataFilter(b,a.dataType));if(g[1])for(c in a.converters)i[c.toLowerCase()]=a.converters[c];for(;e=g[++j];)if(e!=="*"){if(h!=="*"&&h!==e){c=i[h+" "+e]||i["* "+e];if(!c)for(d in i){f=d.split(" ");if(f[1]===e){c=i[h+" "+f[0]]||i["* "+f[0]];if(c){c===!0?c=i[d]:i[d]!==!0&&(e=f[0],g.splice(j--,0,e));break}}}if(c!==!0)if(c&&a["throws"])b=c(b);else try{b=c(b)}catch(k){return{state:"parsererror",error:c?k:"No conversion from "+h+" to "+e}}}h=e}return{state:"success",data:b}}function cL(){try{return new a.XMLHttpRequest}catch(b){}}function cM(){try{return new a.ActiveXObject("Microsoft.XMLHTTP")}catch(b){}}function cU(){return setTimeout(function(){cN=b},0),cN=p.now()}function cV(a,b){p.each(b,function(b,c){var d=(cT[b]||[]).concat(cT["*"]),e=0,f=d.length;for(;e<f;e++)if(d[e].call(a,b,c))return})}function cW(a,b,c){var d,e=0,f=0,g=cS.length,h=p.Deferred().always(function(){delete i.elem}),i=function(){var b=cN||cU(),c=Math.max(0,j.startTime+j.duration-b),d=1-(c/j.duration||0),e=0,f=j.tweens.length;for(;e<f;e++)j.tweens[e].run(d);return h.notifyWith(a,[j,d,c]),d<1&&f?c:(h.resolveWith(a,[j]),!1)},j=h.promise({elem:a,props:p.extend({},b),opts:p.extend(!0,{specialEasing:{}},c),originalProperties:b,originalOptions:c,startTime:cN||cU(),duration:c.duration,tweens:[],createTween:function(b,c,d){var e=p.Tween(a,j.opts,b,c,j.opts.specialEasing[b]||j.opts.easing);return j.tweens.push(e),e},stop:function(b){var c=0,d=b?j.tweens.length:0;for(;c<d;c++)j.tweens[c].run(1);return b?h.resolveWith(a,[j,b]):h.rejectWith(a,[j,b]),this}}),k=j.props;cX(k,j.opts.specialEasing);for(;e<g;e++){d=cS[e].call(j,a,k,j.opts);if(d)return d}return cV(j,k),p.isFunction(j.opts.start)&&j.opts.start.call(a,j),p.fx.timer(p.extend(i,{anim:j,queue:j.opts.queue,elem:a})),j.progress(j.opts.progress).done(j.opts.done,j.opts.complete).fail(j.opts.fail).always(j.opts.always)}function cX(a,b){var c,d,e,f,g;for(c in a){d=p.camelCase(c),e=b[d],f=a[c],p.isArray(f)&&(e=f[1],f=a[c]=f[0]),c!==d&&(a[d]=f,delete a[c]),g=p.cssHooks[d];if(g&&"expand"in g){f=g.expand(f),delete a[d];for(c in f)c in a||(a[c]=f[c],b[c]=e)}else b[d]=e}}function cY(a,b,c){var d,e,f,g,h,i,j,k,l=this,m=a.style,n={},o=[],q=a.nodeType&&bZ(a);c.queue||(j=p._queueHooks(a,"fx"),j.unqueued==null&&(j.unqueued=0,k=j.empty.fire,j.empty.fire=function(){j.unqueued||k()}),j.unqueued++,l.always(function(){l.always(function(){j.unqueued--,p.queue(a,"fx").length||j.empty.fire()})})),a.nodeType===1&&("height"in b||"width"in b)&&(c.overflow=[m.overflow,m.overflowX,m.overflowY],p.css(a,"display")==="inline"&&p.css(a,"float")==="none"&&(!p.support.inlineBlockNeedsLayout||cc(a.nodeName)==="inline"?m.display="inline-block":m.zoom=1)),c.overflow&&(m.overflow="hidden",p.support.shrinkWrapBlocks||l.done(function(){m.overflow=c.overflow[0],m.overflowX=c.overflow[1],m.overflowY=c.overflow[2]}));for(d in b){f=b[d];if(cP.exec(f)){delete b[d];if(f===(q?"hide":"show"))continue;o.push(d)}}g=o.length;if(g){h=p._data(a,"fxshow")||p._data(a,"fxshow",{}),q?p(a).show():l.done(function(){p(a).hide()}),l.done(function(){var b;p.removeData(a,"fxshow",!0);for(b in n)p.style(a,b,n[b])});for(d=0;d<g;d++)e=o[d],i=l.createTween(e,q?h[e]:0),n[e]=h[e]||p.style(a,e),e in h||(h[e]=i.start,q&&(i.end=i.start,i.start=e==="width"||e==="height"?1:0))}}function cZ(a,b,c,d,e){return new cZ.prototype.init(a,b,c,d,e)}function c$(a,b){var c,d={height:a},e=0;b=b?1:0;for(;e<4;e+=2-b)c=bV[e],d["margin"+c]=d["padding"+c]=a;return b&&(d.opacity=d.width=a),d}function da(a){return p.isWindow(a)?a:a.nodeType===9?a.defaultView||a.parentWindow:!1}var c,d,e=a.document,f=a.location,g=a.navigator,h=a.jQuery,i=a.$,j=Array.prototype.push,k=Array.prototype.slice,l=Array.prototype.indexOf,m=Object.prototype.toString,n=Object.prototype.hasOwnProperty,o=String.prototype.trim,p=function(a,b){return new p.fn.init(a,b,c)},q=/[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source,r=/\S/,s=/\s+/,t=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,u=/^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,v=/^<(\w+)\s*\/?>(?:<\/\1>|)$/,w=/^[\],:{}\s]*$/,x=/(?:^|:|,)(?:\s*\[)+/g,y=/\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,z=/"[^"\\\r\n]*"|true|false|null|-?(?:\d\d*\.|)\d+(?:[eE][\-+]?\d+|)/g,A=/^-ms-/,B=/-([\da-z])/gi,C=function(a,b){return(b+"").toUpperCase()},D=function(){e.addEventListener?(e.removeEventListener("DOMContentLoaded",D,!1),p.ready()):e.readyState==="complete"&&(e.detachEvent("onreadystatechange",D),p.ready())},E={};p.fn=p.prototype={constructor:p,init:function(a,c,d){var f,g,h,i;if(!a)return this;if(a.nodeType)return this.context=this[0]=a,this.length=1,this;if(typeof a=="string"){a.charAt(0)==="<"&&a.charAt(a.length-1)===">"&&a.length>=3?f=[null,a,null]:f=u.exec(a);if(f&&(f[1]||!c)){if(f[1])return c=c instanceof p?c[0]:c,i=c&&c.nodeType?c.ownerDocument||c:e,a=p.parseHTML(f[1],i,!0),v.test(f[1])&&p.isPlainObject(c)&&this.attr.call(a,c,!0),p.merge(this,a);g=e.getElementById(f[2]);if(g&&g.parentNode){if(g.id!==f[2])return d.find(a);this.length=1,this[0]=g}return this.context=e,this.selector=a,this}return!c||c.jquery?(c||d).find(a):this.constructor(c).find(a)}return p.isFunction(a)?d.ready(a):(a.selector!==b&&(this.selector=a.selector,this.context=a.context),p.makeArray(a,this))},selector:"",jquery:"1.8.2",length:0,size:function(){return this.length},toArray:function(){return k.call(this)},get:function(a){return a==null?this.toArray():a<0?this[this.length+a]:this[a]},pushStack:function(a,b,c){var d=p.merge(this.constructor(),a);return d.prevObject=this,d.context=this.context,b==="find"?d.selector=this.selector+(this.selector?" ":"")+c:b&&(d.selector=this.selector+"."+b+"("+c+")"),d},each:function(a,b){return p.each(this,a,b)},ready:function(a){return p.ready.promise().done(a),this},eq:function(a){return a=+a,a===-1?this.slice(a):this.slice(a,a+1)},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},slice:function(){return this.pushStack(k.apply(this,arguments),"slice",k.call(arguments).join(","))},map:function(a){return this.pushStack(p.map(this,function(b,c){return a.call(b,c,b)}))},end:function(){return this.prevObject||this.constructor(null)},push:j,sort:[].sort,splice:[].splice},p.fn.init.prototype=p.fn,p.extend=p.fn.extend=function(){var a,c,d,e,f,g,h=arguments[0]||{},i=1,j=arguments.length,k=!1;typeof h=="boolean"&&(k=h,h=arguments[1]||{},i=2),typeof h!="object"&&!p.isFunction(h)&&(h={}),j===i&&(h=this,--i);for(;i<j;i++)if((a=arguments[i])!=null)for(c in a){d=h[c],e=a[c];if(h===e)continue;k&&e&&(p.isPlainObject(e)||(f=p.isArray(e)))?(f?(f=!1,g=d&&p.isArray(d)?d:[]):g=d&&p.isPlainObject(d)?d:{},h[c]=p.extend(k,g,e)):e!==b&&(h[c]=e)}return h},p.extend({noConflict:function(b){return a.$===p&&(a.$=i),b&&a.jQuery===p&&(a.jQuery=h),p},isReady:!1,readyWait:1,holdReady:function(a){a?p.readyWait++:p.ready(!0)},ready:function(a){if(a===!0?--p.readyWait:p.isReady)return;if(!e.body)return setTimeout(p.ready,1);p.isReady=!0;if(a!==!0&&--p.readyWait>0)return;d.resolveWith(e,[p]),p.fn.trigger&&p(e).trigger("ready").off("ready")},isFunction:function(a){return p.type(a)==="function"},isArray:Array.isArray||function(a){return p.type(a)==="array"},isWindow:function(a){return a!=null&&a==a.window},isNumeric:function(a){return!isNaN(parseFloat(a))&&isFinite(a)},type:function(a){return a==null?String(a):E[m.call(a)]||"object"},isPlainObject:function(a){if(!a||p.type(a)!=="object"||a.nodeType||p.isWindow(a))return!1;try{if(a.constructor&&!n.call(a,"constructor")&&!n.call(a.constructor.prototype,"isPrototypeOf"))return!1}catch(c){return!1}var d;for(d in a);return d===b||n.call(a,d)},isEmptyObject:function(a){var b;for(b in a)return!1;return!0},error:function(a){throw new Error(a)},parseHTML:function(a,b,c){var d;return!a||typeof a!="string"?null:(typeof b=="boolean"&&(c=b,b=0),b=b||e,(d=v.exec(a))?[b.createElement(d[1])]:(d=p.buildFragment([a],b,c?null:[]),p.merge([],(d.cacheable?p.clone(d.fragment):d.fragment).childNodes)))},parseJSON:function(b){if(!b||typeof b!="string")return null;b=p.trim(b);if(a.JSON&&a.JSON.parse)return a.JSON.parse(b);if(w.test(b.replace(y,"@").replace(z,"]").replace(x,"")))return(new Function("return "+b))();p.error("Invalid JSON: "+b)},parseXML:function(c){var d,e;if(!c||typeof c!="string")return null;try{a.DOMParser?(e=new DOMParser,d=e.parseFromString(c,"text/xml")):(d=new ActiveXObject("Microsoft.XMLDOM"),d.async="false",d.loadXML(c))}catch(f){d=b}return(!d||!d.documentElement||d.getElementsByTagName("parsererror").length)&&p.error("Invalid XML: "+c),d},noop:function(){},globalEval:function(b){b&&r.test(b)&&(a.execScript||function(b){a.eval.call(a,b)})(b)},camelCase:function(a){return a.replace(A,"ms-").replace(B,C)},nodeName:function(a,b){return a.nodeName&&a.nodeName.toLowerCase()===b.toLowerCase()},each:function(a,c,d){var e,f=0,g=a.length,h=g===b||p.isFunction(a);if(d){if(h){for(e in a)if(c.apply(a[e],d)===!1)break}else for(;f<g;)if(c.apply(a[f++],d)===!1)break}else if(h){for(e in a)if(c.call(a[e],e,a[e])===!1)break}else for(;f<g;)if(c.call(a[f],f,a[f++])===!1)break;return a},trim:o&&!o.call("﻿ ")?function(a){return a==null?"":o.call(a)}:function(a){return a==null?"":(a+"").replace(t,"")},makeArray:function(a,b){var c,d=b||[];return a!=null&&(c=p.type(a),a.length==null||c==="string"||c==="function"||c==="regexp"||p.isWindow(a)?j.call(d,a):p.merge(d,a)),d},inArray:function(a,b,c){var d;if(b){if(l)return l.call(b,a,c);d=b.length,c=c?c<0?Math.max(0,d+c):c:0;for(;c<d;c++)if(c in b&&b[c]===a)return c}return-1},merge:function(a,c){var d=c.length,e=a.length,f=0;if(typeof d=="number")for(;f<d;f++)a[e++]=c[f];else while(c[f]!==b)a[e++]=c[f++];return a.length=e,a},grep:function(a,b,c){var d,e=[],f=0,g=a.length;c=!!c;for(;f<g;f++)d=!!b(a[f],f),c!==d&&e.push(a[f]);return e},map:function(a,c,d){var e,f,g=[],h=0,i=a.length,j=a instanceof p||i!==b&&typeof i=="number"&&(i>0&&a[0]&&a[i-1]||i===0||p.isArray(a));if(j)for(;h<i;h++)e=c(a[h],h,d),e!=null&&(g[g.length]=e);else for(f in a)e=c(a[f],f,d),e!=null&&(g[g.length]=e);return g.concat.apply([],g)},guid:1,proxy:function(a,c){var d,e,f;return typeof c=="string"&&(d=a[c],c=a,a=d),p.isFunction(a)?(e=k.call(arguments,2),f=function(){return a.apply(c,e.concat(k.call(arguments)))},f.guid=a.guid=a.guid||p.guid++,f):b},access:function(a,c,d,e,f,g,h){var i,j=d==null,k=0,l=a.length;if(d&&typeof d=="object"){for(k in d)p.access(a,c,k,d[k],1,g,e);f=1}else if(e!==b){i=h===b&&p.isFunction(e),j&&(i?(i=c,c=function(a,b,c){return i.call(p(a),c)}):(c.call(a,e),c=null));if(c)for(;k<l;k++)c(a[k],d,i?e.call(a[k],k,c(a[k],d)):e,h);f=1}return f?a:j?c.call(a):l?c(a[0],d):g},now:function(){return(new Date).getTime()}}),p.ready.promise=function(b){if(!d){d=p.Deferred();if(e.readyState==="complete")setTimeout(p.ready,1);else if(e.addEventListener)e.addEventListener("DOMContentLoaded",D,!1),a.addEventListener("load",p.ready,!1);else{e.attachEvent("onreadystatechange",D),a.attachEvent("onload",p.ready);var c=!1;try{c=a.frameElement==null&&e.documentElement}catch(f){}c&&c.doScroll&&function g(){if(!p.isReady){try{c.doScroll("left")}catch(a){return setTimeout(g,50)}p.ready()}}()}}return d.promise(b)},p.each("Boolean Number String Function Array Date RegExp Object".split(" "),function(a,b){E["[object "+b+"]"]=b.toLowerCase()}),c=p(e);var F={};p.Callbacks=function(a){a=typeof a=="string"?F[a]||G(a):p.extend({},a);var c,d,e,f,g,h,i=[],j=!a.once&&[],k=function(b){c=a.memory&&b,d=!0,h=f||0,f=0,g=i.length,e=!0;for(;i&&h<g;h++)if(i[h].apply(b[0],b[1])===!1&&a.stopOnFalse){c=!1;break}e=!1,i&&(j?j.length&&k(j.shift()):c?i=[]:l.disable())},l={add:function(){if(i){var b=i.length;(function d(b){p.each(b,function(b,c){var e=p.type(c);e==="function"&&(!a.unique||!l.has(c))?i.push(c):c&&c.length&&e!=="string"&&d(c)})})(arguments),e?g=i.length:c&&(f=b,k(c))}return this},remove:function(){return i&&p.each(arguments,function(a,b){var c;while((c=p.inArray(b,i,c))>-1)i.splice(c,1),e&&(c<=g&&g--,c<=h&&h--)}),this},has:function(a){return p.inArray(a,i)>-1},empty:function(){return i=[],this},disable:function(){return i=j=c=b,this},disabled:function(){return!i},lock:function(){return j=b,c||l.disable(),this},locked:function(){return!j},fireWith:function(a,b){return b=b||[],b=[a,b.slice?b.slice():b],i&&(!d||j)&&(e?j.push(b):k(b)),this},fire:function(){return l.fireWith(this,arguments),this},fired:function(){return!!d}};return l},p.extend({Deferred:function(a){var b=[["resolve","done",p.Callbacks("once memory"),"resolved"],["reject","fail",p.Callbacks("once memory"),"rejected"],["notify","progress",p.Callbacks("memory")]],c="pending",d={state:function(){return c},always:function(){return e.done(arguments).fail(arguments),this},then:function(){var a=arguments;return p.Deferred(function(c){p.each(b,function(b,d){var f=d[0],g=a[b];e[d[1]](p.isFunction(g)?function(){var a=g.apply(this,arguments);a&&p.isFunction(a.promise)?a.promise().done(c.resolve).fail(c.reject).progress(c.notify):c[f+"With"](this===e?c:this,[a])}:c[f])}),a=null}).promise()},promise:function(a){return a!=null?p.extend(a,d):d}},e={};return d.pipe=d.then,p.each(b,function(a,f){var g=f[2],h=f[3];d[f[1]]=g.add,h&&g.add(function(){c=h},b[a^1][2].disable,b[2][2].lock),e[f[0]]=g.fire,e[f[0]+"With"]=g.fireWith}),d.promise(e),a&&a.call(e,e),e},when:function(a){var b=0,c=k.call(arguments),d=c.length,e=d!==1||a&&p.isFunction(a.promise)?d:0,f=e===1?a:p.Deferred(),g=function(a,b,c){return function(d){b[a]=this,c[a]=arguments.length>1?k.call(arguments):d,c===h?f.notifyWith(b,c):--e||f.resolveWith(b,c)}},h,i,j;if(d>1){h=new Array(d),i=new Array(d),j=new Array(d);for(;b<d;b++)c[b]&&p.isFunction(c[b].promise)?c[b].promise().done(g(b,j,c)).fail(f.reject).progress(g(b,i,h)):--e}return e||f.resolveWith(j,c),f.promise()}}),p.support=function(){var b,c,d,f,g,h,i,j,k,l,m,n=e.createElement("div");n.setAttribute("className","t"),n.innerHTML="  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>",c=n.getElementsByTagName("*"),d=n.getElementsByTagName("a")[0],d.style.cssText="top:1px;float:left;opacity:.5";if(!c||!c.length)return{};f=e.createElement("select"),g=f.appendChild(e.createElement("option")),h=n.getElementsByTagName("input")[0],b={leadingWhitespace:n.firstChild.nodeType===3,tbody:!n.getElementsByTagName("tbody").length,htmlSerialize:!!n.getElementsByTagName("link").length,style:/top/.test(d.getAttribute("style")),hrefNormalized:d.getAttribute("href")==="/a",opacity:/^0.5/.test(d.style.opacity),cssFloat:!!d.style.cssFloat,checkOn:h.value==="on",optSelected:g.selected,getSetAttribute:n.className!=="t",enctype:!!e.createElement("form").enctype,html5Clone:e.createElement("nav").cloneNode(!0).outerHTML!=="<:nav></:nav>",boxModel:e.compatMode==="CSS1Compat",submitBubbles:!0,changeBubbles:!0,focusinBubbles:!1,deleteExpando:!0,noCloneEvent:!0,inlineBlockNeedsLayout:!1,shrinkWrapBlocks:!1,reliableMarginRight:!0,boxSizingReliable:!0,pixelPosition:!1},h.checked=!0,b.noCloneChecked=h.cloneNode(!0).checked,f.disabled=!0,b.optDisabled=!g.disabled;try{delete n.test}catch(o){b.deleteExpando=!1}!n.addEventListener&&n.attachEvent&&n.fireEvent&&(n.attachEvent("onclick",m=function(){b.noCloneEvent=!1}),n.cloneNode(!0).fireEvent("onclick"),n.detachEvent("onclick",m)),h=e.createElement("input"),h.value="t",h.setAttribute("type","radio"),b.radioValue=h.value==="t",h.setAttribute("checked","checked"),h.setAttribute("name","t"),n.appendChild(h),i=e.createDocumentFragment(),i.appendChild(n.lastChild),b.checkClone=i.cloneNode(!0).cloneNode(!0).lastChild.checked,b.appendChecked=h.checked,i.removeChild(h),i.appendChild(n);if(n.attachEvent)for(k in{submit:!0,change:!0,focusin:!0})j="on"+k,l=j in n,l||(n.setAttribute(j,"return;"),l=typeof n[j]=="function"),b[k+"Bubbles"]=l;return p(function(){var c,d,f,g,h="padding:0;margin:0;border:0;display:block;overflow:hidden;",i=e.getElementsByTagName("body")[0];if(!i)return;c=e.createElement("div"),c.style.cssText="visibility:hidden;border:0;width:0;height:0;position:static;top:0;margin-top:1px",i.insertBefore(c,i.firstChild),d=e.createElement("div"),c.appendChild(d),d.innerHTML="<table><tr><td></td><td>t</td></tr></table>",f=d.getElementsByTagName("td"),f[0].style.cssText="padding:0;margin:0;border:0;display:none",l=f[0].offsetHeight===0,f[0].style.display="",f[1].style.display="none",b.reliableHiddenOffsets=l&&f[0].offsetHeight===0,d.innerHTML="",d.style.cssText="box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;",b.boxSizing=d.offsetWidth===4,b.doesNotIncludeMarginInBodyOffset=i.offsetTop!==1,a.getComputedStyle&&(b.pixelPosition=(a.getComputedStyle(d,null)||{}).top!=="1%",b.boxSizingReliable=(a.getComputedStyle(d,null)||{width:"4px"}).width==="4px",g=e.createElement("div"),g.style.cssText=d.style.cssText=h,g.style.marginRight=g.style.width="0",d.style.width="1px",d.appendChild(g),b.reliableMarginRight=!parseFloat((a.getComputedStyle(g,null)||{}).marginRight)),typeof d.style.zoom!="undefined"&&(d.innerHTML="",d.style.cssText=h+"width:1px;padding:1px;display:inline;zoom:1",b.inlineBlockNeedsLayout=d.offsetWidth===3,d.style.display="block",d.style.overflow="visible",d.innerHTML="<div></div>",d.firstChild.style.width="5px",b.shrinkWrapBlocks=d.offsetWidth!==3,c.style.zoom=1),i.removeChild(c),c=d=f=g=null}),i.removeChild(n),c=d=f=g=h=i=n=null,b}();var H=/(?:\{[\s\S]*\}|\[[\s\S]*\])$/,I=/([A-Z])/g;p.extend({cache:{},deletedIds:[],uuid:0,expando:"jQuery"+(p.fn.jquery+Math.random()).replace(/\D/g,""),noData:{embed:!0,object:"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",applet:!0},hasData:function(a){return a=a.nodeType?p.cache[a[p.expando]]:a[p.expando],!!a&&!K(a)},data:function(a,c,d,e){if(!p.acceptData(a))return;var f,g,h=p.expando,i=typeof c=="string",j=a.nodeType,k=j?p.cache:a,l=j?a[h]:a[h]&&h;if((!l||!k[l]||!e&&!k[l].data)&&i&&d===b)return;l||(j?a[h]=l=p.deletedIds.pop()||p.guid++:l=h),k[l]||(k[l]={},j||(k[l].toJSON=p.noop));if(typeof c=="object"||typeof c=="function")e?k[l]=p.extend(k[l],c):k[l].data=p.extend(k[l].data,c);return f=k[l],e||(f.data||(f.data={}),f=f.data),d!==b&&(f[p.camelCase(c)]=d),i?(g=f[c],g==null&&(g=f[p.camelCase(c)])):g=f,g},removeData:function(a,b,c){if(!p.acceptData(a))return;var d,e,f,g=a.nodeType,h=g?p.cache:a,i=g?a[p.expando]:p.expando;if(!h[i])return;if(b){d=c?h[i]:h[i].data;if(d){p.isArray(b)||(b in d?b=[b]:(b=p.camelCase(b),b in d?b=[b]:b=b.split(" ")));for(e=0,f=b.length;e<f;e++)delete d[b[e]];if(!(c?K:p.isEmptyObject)(d))return}}if(!c){delete h[i].data;if(!K(h[i]))return}g?p.cleanData([a],!0):p.support.deleteExpando||h!=h.window?delete h[i]:h[i]=null},_data:function(a,b,c){return p.data(a,b,c,!0)},acceptData:function(a){var b=a.nodeName&&p.noData[a.nodeName.toLowerCase()];return!b||b!==!0&&a.getAttribute("classid")===b}}),p.fn.extend({data:function(a,c){var d,e,f,g,h,i=this[0],j=0,k=null;if(a===b){if(this.length){k=p.data(i);if(i.nodeType===1&&!p._data(i,"parsedAttrs")){f=i.attributes;for(h=f.length;j<h;j++)g=f[j].name,g.indexOf("data-")||(g=p.camelCase(g.substring(5)),J(i,g,k[g]));p._data(i,"parsedAttrs",!0)}}return k}return typeof a=="object"?this.each(function(){p.data(this,a)}):(d=a.split(".",2),d[1]=d[1]?"."+d[1]:"",e=d[1]+"!",p.access(this,function(c){if(c===b)return k=this.triggerHandler("getData"+e,[d[0]]),k===b&&i&&(k=p.data(i,a),k=J(i,a,k)),k===b&&d[1]?this.data(d[0]):k;d[1]=c,this.each(function(){var b=p(this);b.triggerHandler("setData"+e,d),p.data(this,a,c),b.triggerHandler("changeData"+e,d)})},null,c,arguments.length>1,null,!1))},removeData:function(a){return this.each(function(){p.removeData(this,a)})}}),p.extend({queue:function(a,b,c){var d;if(a)return b=(b||"fx")+"queue",d=p._data(a,b),c&&(!d||p.isArray(c)?d=p._data(a,b,p.makeArray(c)):d.push(c)),d||[]},dequeue:function(a,b){b=b||"fx";var c=p.queue(a,b),d=c.length,e=c.shift(),f=p._queueHooks(a,b),g=function(){p.dequeue(a,b)};e==="inprogress"&&(e=c.shift(),d--),e&&(b==="fx"&&c.unshift("inprogress"),delete f.stop,e.call(a,g,f)),!d&&f&&f.empty.fire()},_queueHooks:function(a,b){var c=b+"queueHooks";return p._data(a,c)||p._data(a,c,{empty:p.Callbacks("once memory").add(function(){p.removeData(a,b+"queue",!0),p.removeData(a,c,!0)})})}}),p.fn.extend({queue:function(a,c){var d=2;return typeof a!="string"&&(c=a,a="fx",d--),arguments.length<d?p.queue(this[0],a):c===b?this:this.each(function(){var b=p.queue(this,a,c);p._queueHooks(this,a),a==="fx"&&b[0]!=="inprogress"&&p.dequeue(this,a)})},dequeue:function(a){return this.each(function(){p.dequeue(this,a)})},delay:function(a,b){return a=p.fx?p.fx.speeds[a]||a:a,b=b||"fx",this.queue(b,function(b,c){var d=setTimeout(b,a);c.stop=function(){clearTimeout(d)}})},clearQueue:function(a){return this.queue(a||"fx",[])},promise:function(a,c){var d,e=1,f=p.Deferred(),g=this,h=this.length,i=function(){--e||f.resolveWith(g,[g])};typeof a!="string"&&(c=a,a=b),a=a||"fx";while(h--)d=p._data(g[h],a+"queueHooks"),d&&d.empty&&(e++,d.empty.add(i));return i(),f.promise(c)}});var L,M,N,O=/[\t\r\n]/g,P=/\r/g,Q=/^(?:button|input)$/i,R=/^(?:button|input|object|select|textarea)$/i,S=/^a(?:rea|)$/i,T=/^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,U=p.support.getSetAttribute;p.fn.extend({attr:function(a,b){return p.access(this,p.attr,a,b,arguments.length>1)},removeAttr:function(a){return this.each(function(){p.removeAttr(this,a)})},prop:function(a,b){return p.access(this,p.prop,a,b,arguments.length>1)},removeProp:function(a){return a=p.propFix[a]||a,this.each(function(){try{this[a]=b,delete this[a]}catch(c){}})},addClass:function(a){var b,c,d,e,f,g,h;if(p.isFunction(a))return this.each(function(b){p(this).addClass(a.call(this,b,this.className))});if(a&&typeof a=="string"){b=a.split(s);for(c=0,d=this.length;c<d;c++){e=this[c];if(e.nodeType===1)if(!e.className&&b.length===1)e.className=a;else{f=" "+e.className+" ";for(g=0,h=b.length;g<h;g++)f.indexOf(" "+b[g]+" ")<0&&(f+=b[g]+" ");e.className=p.trim(f)}}}return this},removeClass:function(a){var c,d,e,f,g,h,i;if(p.isFunction(a))return this.each(function(b){p(this).removeClass(a.call(this,b,this.className))});if(a&&typeof a=="string"||a===b){c=(a||"").split(s);for(h=0,i=this.length;h<i;h++){e=this[h];if(e.nodeType===1&&e.className){d=(" "+e.className+" ").replace(O," ");for(f=0,g=c.length;f<g;f++)while(d.indexOf(" "+c[f]+" ")>=0)d=d.replace(" "+c[f]+" "," ");e.className=a?p.trim(d):""}}}return this},toggleClass:function(a,b){var c=typeof a,d=typeof b=="boolean";return p.isFunction(a)?this.each(function(c){p(this).toggleClass(a.call(this,c,this.className,b),b)}):this.each(function(){if(c==="string"){var e,f=0,g=p(this),h=b,i=a.split(s);while(e=i[f++])h=d?h:!g.hasClass(e),g[h?"addClass":"removeClass"](e)}else if(c==="undefined"||c==="boolean")this.className&&p._data(this,"__className__",this.className),this.className=this.className||a===!1?"":p._data(this,"__className__")||""})},hasClass:function(a){var b=" "+a+" ",c=0,d=this.length;for(;c<d;c++)if(this[c].nodeType===1&&(" "+this[c].className+" ").replace(O," ").indexOf(b)>=0)return!0;return!1},val:function(a){var c,d,e,f=this[0];if(!arguments.length){if(f)return c=p.valHooks[f.type]||p.valHooks[f.nodeName.toLowerCase()],c&&"get"in c&&(d=c.get(f,"value"))!==b?d:(d=f.value,typeof d=="string"?d.replace(P,""):d==null?"":d);return}return e=p.isFunction(a),this.each(function(d){var f,g=p(this);if(this.nodeType!==1)return;e?f=a.call(this,d,g.val()):f=a,f==null?f="":typeof f=="number"?f+="":p.isArray(f)&&(f=p.map(f,function(a){return a==null?"":a+""})),c=p.valHooks[this.type]||p.valHooks[this.nodeName.toLowerCase()];if(!c||!("set"in c)||c.set(this,f,"value")===b)this.value=f})}}),p.extend({valHooks:{option:{get:function(a){var b=a.attributes.value;return!b||b.specified?a.value:a.text}},select:{get:function(a){var b,c,d,e,f=a.selectedIndex,g=[],h=a.options,i=a.type==="select-one";if(f<0)return null;c=i?f:0,d=i?f+1:h.length;for(;c<d;c++){e=h[c];if(e.selected&&(p.support.optDisabled?!e.disabled:e.getAttribute("disabled")===null)&&(!e.parentNode.disabled||!p.nodeName(e.parentNode,"optgroup"))){b=p(e).val();if(i)return b;g.push(b)}}return i&&!g.length&&h.length?p(h[f]).val():g},set:function(a,b){var c=p.makeArray(b);return p(a).find("option").each(function(){this.selected=p.inArray(p(this).val(),c)>=0}),c.length||(a.selectedIndex=-1),c}}},attrFn:{},attr:function(a,c,d,e){var f,g,h,i=a.nodeType;if(!a||i===3||i===8||i===2)return;if(e&&p.isFunction(p.fn[c]))return p(a)[c](d);if(typeof a.getAttribute=="undefined")return p.prop(a,c,d);h=i!==1||!p.isXMLDoc(a),h&&(c=c.toLowerCase(),g=p.attrHooks[c]||(T.test(c)?M:L));if(d!==b){if(d===null){p.removeAttr(a,c);return}return g&&"set"in g&&h&&(f=g.set(a,d,c))!==b?f:(a.setAttribute(c,d+""),d)}return g&&"get"in g&&h&&(f=g.get(a,c))!==null?f:(f=a.getAttribute(c),f===null?b:f)},removeAttr:function(a,b){var c,d,e,f,g=0;if(b&&a.nodeType===1){d=b.split(s);for(;g<d.length;g++)e=d[g],e&&(c=p.propFix[e]||e,f=T.test(e),f||p.attr(a,e,""),a.removeAttribute(U?e:c),f&&c in a&&(a[c]=!1))}},attrHooks:{type:{set:function(a,b){if(Q.test(a.nodeName)&&a.parentNode)p.error("type property can't be changed");else if(!p.support.radioValue&&b==="radio"&&p.nodeName(a,"input")){var c=a.value;return a.setAttribute("type",b),c&&(a.value=c),b}}},value:{get:function(a,b){return L&&p.nodeName(a,"button")?L.get(a,b):b in a?a.value:null},set:function(a,b,c){if(L&&p.nodeName(a,"button"))return L.set(a,b,c);a.value=b}}},propFix:{tabindex:"tabIndex",readonly:"readOnly","for":"htmlFor","class":"className",maxlength:"maxLength",cellspacing:"cellSpacing",cellpadding:"cellPadding",rowspan:"rowSpan",colspan:"colSpan",usemap:"useMap",frameborder:"frameBorder",contenteditable:"contentEditable"},prop:function(a,c,d){var e,f,g,h=a.nodeType;if(!a||h===3||h===8||h===2)return;return g=h!==1||!p.isXMLDoc(a),g&&(c=p.propFix[c]||c,f=p.propHooks[c]),d!==b?f&&"set"in f&&(e=f.set(a,d,c))!==b?e:a[c]=d:f&&"get"in f&&(e=f.get(a,c))!==null?e:a[c]},propHooks:{tabIndex:{get:function(a){var c=a.getAttributeNode("tabindex");return c&&c.specified?parseInt(c.value,10):R.test(a.nodeName)||S.test(a.nodeName)&&a.href?0:b}}}}),M={get:function(a,c){var d,e=p.prop(a,c);return e===!0||typeof e!="boolean"&&(d=a.getAttributeNode(c))&&d.nodeValue!==!1?c.toLowerCase():b},set:function(a,b,c){var d;return b===!1?p.removeAttr(a,c):(d=p.propFix[c]||c,d in a&&(a[d]=!0),a.setAttribute(c,c.toLowerCase())),c}},U||(N={name:!0,id:!0,coords:!0},L=p.valHooks.button={get:function(a,c){var d;return d=a.getAttributeNode(c),d&&(N[c]?d.value!=="":d.specified)?d.value:b},set:function(a,b,c){var d=a.getAttributeNode(c);return d||(d=e.createAttribute(c),a.setAttributeNode(d)),d.value=b+""}},p.each(["width","height"],function(a,b){p.attrHooks[b]=p.extend(p.attrHooks[b],{set:function(a,c){if(c==="")return a.setAttribute(b,"auto"),c}})}),p.attrHooks.contenteditable={get:L.get,set:function(a,b,c){b===""&&(b="false"),L.set(a,b,c)}}),p.support.hrefNormalized||p.each(["href","src","width","height"],function(a,c){p.attrHooks[c]=p.extend(p.attrHooks[c],{get:function(a){var d=a.getAttribute(c,2);return d===null?b:d}})}),p.support.style||(p.attrHooks.style={get:function(a){return a.style.cssText.toLowerCase()||b},set:function(a,b){return a.style.cssText=b+""}}),p.support.optSelected||(p.propHooks.selected=p.extend(p.propHooks.selected,{get:function(a){var b=a.parentNode;return b&&(b.selectedIndex,b.parentNode&&b.parentNode.selectedIndex),null}})),p.support.enctype||(p.propFix.enctype="encoding"),p.support.checkOn||p.each(["radio","checkbox"],function(){p.valHooks[this]={get:function(a){return a.getAttribute("value")===null?"on":a.value}}}),p.each(["radio","checkbox"],function(){p.valHooks[this]=p.extend(p.valHooks[this],{set:function(a,b){if(p.isArray(b))return a.checked=p.inArray(p(a).val(),b)>=0}})});var V=/^(?:textarea|input|select)$/i,W=/^([^\.]*|)(?:\.(.+)|)$/,X=/(?:^|\s)hover(\.\S+|)\b/,Y=/^key/,Z=/^(?:mouse|contextmenu)|click/,$=/^(?:focusinfocus|focusoutblur)$/,_=function(a){return p.event.special.hover?a:a.replace(X,"mouseenter$1 mouseleave$1")};p.event={add:function(a,c,d,e,f){var g,h,i,j,k,l,m,n,o,q,r;if(a.nodeType===3||a.nodeType===8||!c||!d||!(g=p._data(a)))return;d.handler&&(o=d,d=o.handler,f=o.selector),d.guid||(d.guid=p.guid++),i=g.events,i||(g.events=i={}),h=g.handle,h||(g.handle=h=function(a){return typeof p!="undefined"&&(!a||p.event.triggered!==a.type)?p.event.dispatch.apply(h.elem,arguments):b},h.elem=a),c=p.trim(_(c)).split(" ");for(j=0;j<c.length;j++){k=W.exec(c[j])||[],l=k[1],m=(k[2]||"").split(".").sort(),r=p.event.special[l]||{},l=(f?r.delegateType:r.bindType)||l,r=p.event.special[l]||{},n=p.extend({type:l,origType:k[1],data:e,handler:d,guid:d.guid,selector:f,needsContext:f&&p.expr.match.needsContext.test(f),namespace:m.join(".")},o),q=i[l];if(!q){q=i[l]=[],q.delegateCount=0;if(!r.setup||r.setup.call(a,e,m,h)===!1)a.addEventListener?a.addEventListener(l,h,!1):a.attachEvent&&a.attachEvent("on"+l,h)}r.add&&(r.add.call(a,n),n.handler.guid||(n.handler.guid=d.guid)),f?q.splice(q.delegateCount++,0,n):q.push(n),p.event.global[l]=!0}a=null},global:{},remove:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,n,o,q,r=p.hasData(a)&&p._data(a);if(!r||!(m=r.events))return;b=p.trim(_(b||"")).split(" ");for(f=0;f<b.length;f++){g=W.exec(b[f])||[],h=i=g[1],j=g[2];if(!h){for(h in m)p.event.remove(a,h+b[f],c,d,!0);continue}n=p.event.special[h]||{},h=(d?n.delegateType:n.bindType)||h,o=m[h]||[],k=o.length,j=j?new RegExp("(^|\\.)"+j.split(".").sort().join("\\.(?:.*\\.|)")+"(\\.|$)"):null;for(l=0;l<o.length;l++)q=o[l],(e||i===q.origType)&&(!c||c.guid===q.guid)&&(!j||j.test(q.namespace))&&(!d||d===q.selector||d==="**"&&q.selector)&&(o.splice(l--,1),q.selector&&o.delegateCount--,n.remove&&n.remove.call(a,q));o.length===0&&k!==o.length&&((!n.teardown||n.teardown.call(a,j,r.handle)===!1)&&p.removeEvent(a,h,r.handle),delete m[h])}p.isEmptyObject(m)&&(delete r.handle,p.removeData(a,"events",!0))},customEvent:{getData:!0,setData:!0,changeData:!0},trigger:function(c,d,f,g){if(!f||f.nodeType!==3&&f.nodeType!==8){var h,i,j,k,l,m,n,o,q,r,s=c.type||c,t=[];if($.test(s+p.event.triggered))return;s.indexOf("!")>=0&&(s=s.slice(0,-1),i=!0),s.indexOf(".")>=0&&(t=s.split("."),s=t.shift(),t.sort());if((!f||p.event.customEvent[s])&&!p.event.global[s])return;c=typeof c=="object"?c[p.expando]?c:new p.Event(s,c):new p.Event(s),c.type=s,c.isTrigger=!0,c.exclusive=i,c.namespace=t.join("."),c.namespace_re=c.namespace?new RegExp("(^|\\.)"+t.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,m=s.indexOf(":")<0?"on"+s:"";if(!f){h=p.cache;for(j in h)h[j].events&&h[j].events[s]&&p.event.trigger(c,d,h[j].handle.elem,!0);return}c.result=b,c.target||(c.target=f),d=d!=null?p.makeArray(d):[],d.unshift(c),n=p.event.special[s]||{};if(n.trigger&&n.trigger.apply(f,d)===!1)return;q=[[f,n.bindType||s]];if(!g&&!n.noBubble&&!p.isWindow(f)){r=n.delegateType||s,k=$.test(r+s)?f:f.parentNode;for(l=f;k;k=k.parentNode)q.push([k,r]),l=k;l===(f.ownerDocument||e)&&q.push([l.defaultView||l.parentWindow||a,r])}for(j=0;j<q.length&&!c.isPropagationStopped();j++)k=q[j][0],c.type=q[j][1],o=(p._data(k,"events")||{})[c.type]&&p._data(k,"handle"),o&&o.apply(k,d),o=m&&k[m],o&&p.acceptData(k)&&o.apply&&o.apply(k,d)===!1&&c.preventDefault();return c.type=s,!g&&!c.isDefaultPrevented()&&(!n._default||n._default.apply(f.ownerDocument,d)===!1)&&(s!=="click"||!p.nodeName(f,"a"))&&p.acceptData(f)&&m&&f[s]&&(s!=="focus"&&s!=="blur"||c.target.offsetWidth!==0)&&!p.isWindow(f)&&(l=f[m],l&&(f[m]=null),p.event.triggered=s,f[s](),p.event.triggered=b,l&&(f[m]=l)),c.result}return},dispatch:function(c){c=p.event.fix(c||a.event);var d,e,f,g,h,i,j,l,m,n,o=(p._data(this,"events")||{})[c.type]||[],q=o.delegateCount,r=k.call(arguments),s=!c.exclusive&&!c.namespace,t=p.event.special[c.type]||{},u=[];r[0]=c,c.delegateTarget=this;if(t.preDispatch&&t.preDispatch.call(this,c)===!1)return;if(q&&(!c.button||c.type!=="click"))for(f=c.target;f!=this;f=f.parentNode||this)if(f.disabled!==!0||c.type!=="click"){h={},j=[];for(d=0;d<q;d++)l=o[d],m=l.selector,h[m]===b&&(h[m]=l.needsContext?p(m,this).index(f)>=0:p.find(m,this,null,[f]).length),h[m]&&j.push(l);j.length&&u.push({elem:f,matches:j})}o.length>q&&u.push({elem:this,matches:o.slice(q)});for(d=0;d<u.length&&!c.isPropagationStopped();d++){i=u[d],c.currentTarget=i.elem;for(e=0;e<i.matches.length&&!c.isImmediatePropagationStopped();e++){l=i.matches[e];if(s||!c.namespace&&!l.namespace||c.namespace_re&&c.namespace_re.test(l.namespace))c.data=l.data,c.handleObj=l,g=((p.event.special[l.origType]||{}).handle||l.handler).apply(i.elem,r),g!==b&&(c.result=g,g===!1&&(c.preventDefault(),c.stopPropagation()))}}return t.postDispatch&&t.postDispatch.call(this,c),c.result},props:"attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),fixHooks:{},keyHooks:{props:"char charCode key keyCode".split(" "),filter:function(a,b){return a.which==null&&(a.which=b.charCode!=null?b.charCode:b.keyCode),a}},mouseHooks:{props:"button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),filter:function(a,c){var d,f,g,h=c.button,i=c.fromElement;return a.pageX==null&&c.clientX!=null&&(d=a.target.ownerDocument||e,f=d.documentElement,g=d.body,a.pageX=c.clientX+(f&&f.scrollLeft||g&&g.scrollLeft||0)-(f&&f.clientLeft||g&&g.clientLeft||0),a.pageY=c.clientY+(f&&f.scrollTop||g&&g.scrollTop||0)-(f&&f.clientTop||g&&g.clientTop||0)),!a.relatedTarget&&i&&(a.relatedTarget=i===a.target?c.toElement:i),!a.which&&h!==b&&(a.which=h&1?1:h&2?3:h&4?2:0),a}},fix:function(a){if(a[p.expando])return a;var b,c,d=a,f=p.event.fixHooks[a.type]||{},g=f.props?this.props.concat(f.props):this.props;a=p.Event(d);for(b=g.length;b;)c=g[--b],a[c]=d[c];return a.target||(a.target=d.srcElement||e),a.target.nodeType===3&&(a.target=a.target.parentNode),a.metaKey=!!a.metaKey,f.filter?f.filter(a,d):a},special:{load:{noBubble:!0},focus:{delegateType:"focusin"},blur:{delegateType:"focusout"},beforeunload:{setup:function(a,b,c){p.isWindow(this)&&(this.onbeforeunload=c)},teardown:function(a,b){this.onbeforeunload===b&&(this.onbeforeunload=null)}}},simulate:function(a,b,c,d){var e=p.extend(new p.Event,c,{type:a,isSimulated:!0,originalEvent:{}});d?p.event.trigger(e,null,b):p.event.dispatch.call(b,e),e.isDefaultPrevented()&&c.preventDefault()}},p.event.handle=p.event.dispatch,p.removeEvent=e.removeEventListener?function(a,b,c){a.removeEventListener&&a.removeEventListener(b,c,!1)}:function(a,b,c){var d="on"+b;a.detachEvent&&(typeof a[d]=="undefined"&&(a[d]=null),a.detachEvent(d,c))},p.Event=function(a,b){if(this instanceof p.Event)a&&a.type?(this.originalEvent=a,this.type=a.type,this.isDefaultPrevented=a.defaultPrevented||a.returnValue===!1||a.getPreventDefault&&a.getPreventDefault()?bb:ba):this.type=a,b&&p.extend(this,b),this.timeStamp=a&&a.timeStamp||p.now(),this[p.expando]=!0;else return new p.Event(a,b)},p.Event.prototype={preventDefault:function(){this.isDefaultPrevented=bb;var a=this.originalEvent;if(!a)return;a.preventDefault?a.preventDefault():a.returnValue=!1},stopPropagation:function(){this.isPropagationStopped=bb;var a=this.originalEvent;if(!a)return;a.stopPropagation&&a.stopPropagation(),a.cancelBubble=!0},stopImmediatePropagation:function(){this.isImmediatePropagationStopped=bb,this.stopPropagation()},isDefaultPrevented:ba,isPropagationStopped:ba,isImmediatePropagationStopped:ba},p.each({mouseenter:"mouseover",mouseleave:"mouseout"},function(a,b){p.event.special[a]={delegateType:b,bindType:b,handle:function(a){var c,d=this,e=a.relatedTarget,f=a.handleObj,g=f.selector;if(!e||e!==d&&!p.contains(d,e))a.type=f.origType,c=f.handler.apply(this,arguments),a.type=b;return c}}}),p.support.submitBubbles||(p.event.special.submit={setup:function(){if(p.nodeName(this,"form"))return!1;p.event.add(this,"click._submit keypress._submit",function(a){var c=a.target,d=p.nodeName(c,"input")||p.nodeName(c,"button")?c.form:b;d&&!p._data(d,"_submit_attached")&&(p.event.add(d,"submit._submit",function(a){a._submit_bubble=!0}),p._data(d,"_submit_attached",!0))})},postDispatch:function(a){a._submit_bubble&&(delete a._submit_bubble,this.parentNode&&!a.isTrigger&&p.event.simulate("submit",this.parentNode,a,!0))},teardown:function(){if(p.nodeName(this,"form"))return!1;p.event.remove(this,"._submit")}}),p.support.changeBubbles||(p.event.special.change={setup:function(){if(V.test(this.nodeName)){if(this.type==="checkbox"||this.type==="radio")p.event.add(this,"propertychange._change",function(a){a.originalEvent.propertyName==="checked"&&(this._just_changed=!0)}),p.event.add(this,"click._change",function(a){this._just_changed&&!a.isTrigger&&(this._just_changed=!1),p.event.simulate("change",this,a,!0)});return!1}p.event.add(this,"beforeactivate._change",function(a){var b=a.target;V.test(b.nodeName)&&!p._data(b,"_change_attached")&&(p.event.add(b,"change._change",function(a){this.parentNode&&!a.isSimulated&&!a.isTrigger&&p.event.simulate("change",this.parentNode,a,!0)}),p._data(b,"_change_attached",!0))})},handle:function(a){var b=a.target;if(this!==b||a.isSimulated||a.isTrigger||b.type!=="radio"&&b.type!=="checkbox")return a.handleObj.handler.apply(this,arguments)},teardown:function(){return p.event.remove(this,"._change"),!V.test(this.nodeName)}}),p.support.focusinBubbles||p.each({focus:"focusin",blur:"focusout"},function(a,b){var c=0,d=function(a){p.event.simulate(b,a.target,p.event.fix(a),!0)};p.event.special[b]={setup:function(){c++===0&&e.addEventListener(a,d,!0)},teardown:function(){--c===0&&e.removeEventListener(a,d,!0)}}}),p.fn.extend({on:function(a,c,d,e,f){var g,h;if(typeof a=="object"){typeof c!="string"&&(d=d||c,c=b);for(h in a)this.on(h,c,d,a[h],f);return this}d==null&&e==null?(e=c,d=c=b):e==null&&(typeof c=="string"?(e=d,d=b):(e=d,d=c,c=b));if(e===!1)e=ba;else if(!e)return this;return f===1&&(g=e,e=function(a){return p().off(a),g.apply(this,arguments)},e.guid=g.guid||(g.guid=p.guid++)),this.each(function(){p.event.add(this,a,e,d,c)})},one:function(a,b,c,d){return this.on(a,b,c,d,1)},off:function(a,c,d){var e,f;if(a&&a.preventDefault&&a.handleObj)return e=a.handleObj,p(a.delegateTarget).off(e.namespace?e.origType+"."+e.namespace:e.origType,e.selector,e.handler),this;if(typeof a=="object"){for(f in a)this.off(f,c,a[f]);return this}if(c===!1||typeof c=="function")d=c,c=b;return d===!1&&(d=ba),this.each(function(){p.event.remove(this,a,d,c)})},bind:function(a,b,c){return this.on(a,null,b,c)},unbind:function(a,b){return this.off(a,null,b)},live:function(a,b,c){return p(this.context).on(a,this.selector,b,c),this},die:function(a,b){return p(this.context).off(a,this.selector||"**",b),this},delegate:function(a,b,c,d){return this.on(b,a,c,d)},undelegate:function(a,b,c){return arguments.length===1?this.off(a,"**"):this.off(b,a||"**",c)},trigger:function(a,b){return this.each(function(){p.event.trigger(a,b,this)})},triggerHandler:function(a,b){if(this[0])return p.event.trigger(a,b,this[0],!0)},toggle:function(a){var b=arguments,c=a.guid||p.guid++,d=0,e=function(c){var e=(p._data(this,"lastToggle"+a.guid)||0)%d;return p._data(this,"lastToggle"+a.guid,e+1),c.preventDefault(),b[e].apply(this,arguments)||!1};e.guid=c;while(d<b.length)b[d++].guid=c;return this.click(e)},hover:function(a,b){return this.mouseenter(a).mouseleave(b||a)}}),p.each("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error contextmenu".split(" "),function(a,b){p.fn[b]=function(a,c){return c==null&&(c=a,a=null),arguments.length>0?this.on(b,null,a,c):this.trigger(b)},Y.test(b)&&(p.event.fixHooks[b]=p.event.keyHooks),Z.test(b)&&(p.event.fixHooks[b]=p.event.mouseHooks)}),function(a,b){function bc(a,b,c,d){c=c||[],b=b||r;var e,f,i,j,k=b.nodeType;if(!a||typeof a!="string")return c;if(k!==1&&k!==9)return[];i=g(b);if(!i&&!d)if(e=P.exec(a))if(j=e[1]){if(k===9){f=b.getElementById(j);if(!f||!f.parentNode)return c;if(f.id===j)return c.push(f),c}else if(b.ownerDocument&&(f=b.ownerDocument.getElementById(j))&&h(b,f)&&f.id===j)return c.push(f),c}else{if(e[2])return w.apply(c,x.call(b.getElementsByTagName(a),0)),c;if((j=e[3])&&_&&b.getElementsByClassName)return w.apply(c,x.call(b.getElementsByClassName(j),0)),c}return bp(a.replace(L,"$1"),b,c,d,i)}function bd(a){return function(b){var c=b.nodeName.toLowerCase();return c==="input"&&b.type===a}}function be(a){return function(b){var c=b.nodeName.toLowerCase();return(c==="input"||c==="button")&&b.type===a}}function bf(a){return z(function(b){return b=+b,z(function(c,d){var e,f=a([],c.length,b),g=f.length;while(g--)c[e=f[g]]&&(c[e]=!(d[e]=c[e]))})})}function bg(a,b,c){if(a===b)return c;var d=a.nextSibling;while(d){if(d===b)return-1;d=d.nextSibling}return 1}function bh(a,b){var c,d,f,g,h,i,j,k=C[o][a];if(k)return b?0:k.slice(0);h=a,i=[],j=e.preFilter;while(h){if(!c||(d=M.exec(h)))d&&(h=h.slice(d[0].length)),i.push(f=[]);c=!1;if(d=N.exec(h))f.push(c=new q(d.shift())),h=h.slice(c.length),c.type=d[0].replace(L," ");for(g in e.filter)(d=W[g].exec(h))&&(!j[g]||(d=j[g](d,r,!0)))&&(f.push(c=new q(d.shift())),h=h.slice(c.length),c.type=g,c.matches=d);if(!c)break}return b?h.length:h?bc.error(a):C(a,i).slice(0)}function bi(a,b,d){var e=b.dir,f=d&&b.dir==="parentNode",g=u++;return b.first?function(b,c,d){while(b=b[e])if(f||b.nodeType===1)return a(b,c,d)}:function(b,d,h){if(!h){var i,j=t+" "+g+" ",k=j+c;while(b=b[e])if(f||b.nodeType===1){if((i=b[o])===k)return b.sizset;if(typeof i=="string"&&i.indexOf(j)===0){if(b.sizset)return b}else{b[o]=k;if(a(b,d,h))return b.sizset=!0,b;b.sizset=!1}}}else while(b=b[e])if(f||b.nodeType===1)if(a(b,d,h))return b}}function bj(a){return a.length>1?function(b,c,d){var e=a.length;while(e--)if(!a[e](b,c,d))return!1;return!0}:a[0]}function bk(a,b,c,d,e){var f,g=[],h=0,i=a.length,j=b!=null;for(;h<i;h++)if(f=a[h])if(!c||c(f,d,e))g.push(f),j&&b.push(h);return g}function bl(a,b,c,d,e,f){return d&&!d[o]&&(d=bl(d)),e&&!e[o]&&(e=bl(e,f)),z(function(f,g,h,i){if(f&&e)return;var j,k,l,m=[],n=[],o=g.length,p=f||bo(b||"*",h.nodeType?[h]:h,[],f),q=a&&(f||!b)?bk(p,m,a,h,i):p,r=c?e||(f?a:o||d)?[]:g:q;c&&c(q,r,h,i);if(d){l=bk(r,n),d(l,[],h,i),j=l.length;while(j--)if(k=l[j])r[n[j]]=!(q[n[j]]=k)}if(f){j=a&&r.length;while(j--)if(k=r[j])f[m[j]]=!(g[m[j]]=k)}else r=bk(r===g?r.splice(o,r.length):r),e?e(null,g,r,i):w.apply(g,r)})}function bm(a){var b,c,d,f=a.length,g=e.relative[a[0].type],h=g||e.relative[" "],i=g?1:0,j=bi(function(a){return a===b},h,!0),k=bi(function(a){return y.call(b,a)>-1},h,!0),m=[function(a,c,d){return!g&&(d||c!==l)||((b=c).nodeType?j(a,c,d):k(a,c,d))}];for(;i<f;i++)if(c=e.relative[a[i].type])m=[bi(bj(m),c)];else{c=e.filter[a[i].type].apply(null,a[i].matches);if(c[o]){d=++i;for(;d<f;d++)if(e.relative[a[d].type])break;return bl(i>1&&bj(m),i>1&&a.slice(0,i-1).join("").replace(L,"$1"),c,i<d&&bm(a.slice(i,d)),d<f&&bm(a=a.slice(d)),d<f&&a.join(""))}m.push(c)}return bj(m)}function bn(a,b){var d=b.length>0,f=a.length>0,g=function(h,i,j,k,m){var n,o,p,q=[],s=0,u="0",x=h&&[],y=m!=null,z=l,A=h||f&&e.find.TAG("*",m&&i.parentNode||i),B=t+=z==null?1:Math.E;y&&(l=i!==r&&i,c=g.el);for(;(n=A[u])!=null;u++){if(f&&n){for(o=0;p=a[o];o++)if(p(n,i,j)){k.push(n);break}y&&(t=B,c=++g.el)}d&&((n=!p&&n)&&s--,h&&x.push(n))}s+=u;if(d&&u!==s){for(o=0;p=b[o];o++)p(x,q,i,j);if(h){if(s>0)while(u--)!x[u]&&!q[u]&&(q[u]=v.call(k));q=bk(q)}w.apply(k,q),y&&!h&&q.length>0&&s+b.length>1&&bc.uniqueSort(k)}return y&&(t=B,l=z),x};return g.el=0,d?z(g):g}function bo(a,b,c,d){var e=0,f=b.length;for(;e<f;e++)bc(a,b[e],c,d);return c}function bp(a,b,c,d,f){var g,h,j,k,l,m=bh(a),n=m.length;if(!d&&m.length===1){h=m[0]=m[0].slice(0);if(h.length>2&&(j=h[0]).type==="ID"&&b.nodeType===9&&!f&&e.relative[h[1].type]){b=e.find.ID(j.matches[0].replace(V,""),b,f)[0];if(!b)return c;a=a.slice(h.shift().length)}for(g=W.POS.test(a)?-1:h.length-1;g>=0;g--){j=h[g];if(e.relative[k=j.type])break;if(l=e.find[k])if(d=l(j.matches[0].replace(V,""),R.test(h[0].type)&&b.parentNode||b,f)){h.splice(g,1),a=d.length&&h.join("");if(!a)return w.apply(c,x.call(d,0)),c;break}}}return i(a,m)(d,b,f,c,R.test(a)),c}function bq(){}var c,d,e,f,g,h,i,j,k,l,m=!0,n="undefined",o=("sizcache"+Math.random()).replace(".",""),q=String,r=a.document,s=r.documentElement,t=0,u=0,v=[].pop,w=[].push,x=[].slice,y=[].indexOf||function(a){var b=0,c=this.length;for(;b<c;b++)if(this[b]===a)return b;return-1},z=function(a,b){return a[o]=b==null||b,a},A=function(){var a={},b=[];return z(function(c,d){return b.push(c)>e.cacheLength&&delete a[b.shift()],a[c]=d},a)},B=A(),C=A(),D=A(),E="[\\x20\\t\\r\\n\\f]",F="(?:\\\\.|[-\\w]|[^\\x00-\\xa0])+",G=F.replace("w","w#"),H="([*^$|!~]?=)",I="\\["+E+"*("+F+")"+E+"*(?:"+H+E+"*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|("+G+")|)|)"+E+"*\\]",J=":("+F+")(?:\\((?:(['\"])((?:\\\\.|[^\\\\])*?)\\2|([^()[\\]]*|(?:(?:"+I+")|[^:]|\\\\.)*|.*))\\)|)",K=":(even|odd|eq|gt|lt|nth|first|last)(?:\\("+E+"*((?:-\\d)?\\d*)"+E+"*\\)|)(?=[^-]|$)",L=new RegExp("^"+E+"+|((?:^|[^\\\\])(?:\\\\.)*)"+E+"+$","g"),M=new RegExp("^"+E+"*,"+E+"*"),N=new RegExp("^"+E+"*([\\x20\\t\\r\\n\\f>+~])"+E+"*"),O=new RegExp(J),P=/^(?:#([\w\-]+)|(\w+)|\.([\w\-]+))$/,Q=/^:not/,R=/[\x20\t\r\n\f]*[+~]/,S=/:not\($/,T=/h\d/i,U=/input|select|textarea|button/i,V=/\\(?!\\)/g,W={ID:new RegExp("^#("+F+")"),CLASS:new RegExp("^\\.("+F+")"),NAME:new RegExp("^\\[name=['\"]?("+F+")['\"]?\\]"),TAG:new RegExp("^("+F.replace("w","w*")+")"),ATTR:new RegExp("^"+I),PSEUDO:new RegExp("^"+J),POS:new RegExp(K,"i"),CHILD:new RegExp("^:(only|nth|first|last)-child(?:\\("+E+"*(even|odd|(([+-]|)(\\d*)n|)"+E+"*(?:([+-]|)"+E+"*(\\d+)|))"+E+"*\\)|)","i"),needsContext:new RegExp("^"+E+"*[>+~]|"+K,"i")},X=function(a){var b=r.createElement("div");try{return a(b)}catch(c){return!1}finally{b=null}},Y=X(function(a){return a.appendChild(r.createComment("")),!a.getElementsByTagName("*").length}),Z=X(function(a){return a.innerHTML="<a href='#'></a>",a.firstChild&&typeof a.firstChild.getAttribute!==n&&a.firstChild.getAttribute("href")==="#"}),$=X(function(a){a.innerHTML="<select></select>";var b=typeof a.lastChild.getAttribute("multiple");return b!=="boolean"&&b!=="string"}),_=X(function(a){return a.innerHTML="<div class='hidden e'></div><div class='hidden'></div>",!a.getElementsByClassName||!a.getElementsByClassName("e").length?!1:(a.lastChild.className="e",a.getElementsByClassName("e").length===2)}),ba=X(function(a){a.id=o+0,a.innerHTML="<a name='"+o+"'></a><div name='"+o+"'></div>",s.insertBefore(a,s.firstChild);var b=r.getElementsByName&&r.getElementsByName(o).length===2+r.getElementsByName(o+0).length;return d=!r.getElementById(o),s.removeChild(a),b});try{x.call(s.childNodes,0)[0].nodeType}catch(bb){x=function(a){var b,c=[];for(;b=this[a];a++)c.push(b);return c}}bc.matches=function(a,b){return bc(a,null,null,b)},bc.matchesSelector=function(a,b){return bc(b,null,null,[a]).length>0},f=bc.getText=function(a){var b,c="",d=0,e=a.nodeType;if(e){if(e===1||e===9||e===11){if(typeof a.textContent=="string")return a.textContent;for(a=a.firstChild;a;a=a.nextSibling)c+=f(a)}else if(e===3||e===4)return a.nodeValue}else for(;b=a[d];d++)c+=f(b);return c},g=bc.isXML=function(a){var b=a&&(a.ownerDocument||a).documentElement;return b?b.nodeName!=="HTML":!1},h=bc.contains=s.contains?function(a,b){var c=a.nodeType===9?a.documentElement:a,d=b&&b.parentNode;return a===d||!!(d&&d.nodeType===1&&c.contains&&c.contains(d))}:s.compareDocumentPosition?function(a,b){return b&&!!(a.compareDocumentPosition(b)&16)}:function(a,b){while(b=b.parentNode)if(b===a)return!0;return!1},bc.attr=function(a,b){var c,d=g(a);return d||(b=b.toLowerCase()),(c=e.attrHandle[b])?c(a):d||$?a.getAttribute(b):(c=a.getAttributeNode(b),c?typeof a[b]=="boolean"?a[b]?b:null:c.specified?c.value:null:null)},e=bc.selectors={cacheLength:50,createPseudo:z,match:W,attrHandle:Z?{}:{href:function(a){return a.getAttribute("href",2)},type:function(a){return a.getAttribute("type")}},find:{ID:d?function(a,b,c){if(typeof b.getElementById!==n&&!c){var d=b.getElementById(a);return d&&d.parentNode?[d]:[]}}:function(a,c,d){if(typeof c.getElementById!==n&&!d){var e=c.getElementById(a);return e?e.id===a||typeof e.getAttributeNode!==n&&e.getAttributeNode("id").value===a?[e]:b:[]}},TAG:Y?function(a,b){if(typeof b.getElementsByTagName!==n)return b.getElementsByTagName(a)}:function(a,b){var c=b.getElementsByTagName(a);if(a==="*"){var d,e=[],f=0;for(;d=c[f];f++)d.nodeType===1&&e.push(d);return e}return c},NAME:ba&&function(a,b){if(typeof b.getElementsByName!==n)return b.getElementsByName(name)},CLASS:_&&function(a,b,c){if(typeof b.getElementsByClassName!==n&&!c)return b.getElementsByClassName(a)}},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(a){return a[1]=a[1].replace(V,""),a[3]=(a[4]||a[5]||"").replace(V,""),a[2]==="~="&&(a[3]=" "+a[3]+" "),a.slice(0,4)},CHILD:function(a){return a[1]=a[1].toLowerCase(),a[1]==="nth"?(a[2]||bc.error(a[0]),a[3]=+(a[3]?a[4]+(a[5]||1):2*(a[2]==="even"||a[2]==="odd")),a[4]=+(a[6]+a[7]||a[2]==="odd")):a[2]&&bc.error(a[0]),a},PSEUDO:function(a){var b,c;if(W.CHILD.test(a[0]))return null;if(a[3])a[2]=a[3];else if(b=a[4])O.test(b)&&(c=bh(b,!0))&&(c=b.indexOf(")",b.length-c)-b.length)&&(b=b.slice(0,c),a[0]=a[0].slice(0,c)),a[2]=b;return a.slice(0,3)}},filter:{ID:d?function(a){return a=a.replace(V,""),function(b){return b.getAttribute("id")===a}}:function(a){return a=a.replace(V,""),function(b){var c=typeof b.getAttributeNode!==n&&b.getAttributeNode("id");return c&&c.value===a}},TAG:function(a){return a==="*"?function(){return!0}:(a=a.replace(V,"").toLowerCase(),function(b){return b.nodeName&&b.nodeName.toLowerCase()===a})},CLASS:function(a){var b=B[o][a];return b||(b=B(a,new RegExp("(^|"+E+")"+a+"("+E+"|$)"))),function(a){return b.test(a.className||typeof a.getAttribute!==n&&a.getAttribute("class")||"")}},ATTR:function(a,b,c){return function(d,e){var f=bc.attr(d,a);return f==null?b==="!=":b?(f+="",b==="="?f===c:b==="!="?f!==c:b==="^="?c&&f.indexOf(c)===0:b==="*="?c&&f.indexOf(c)>-1:b==="$="?c&&f.substr(f.length-c.length)===c:b==="~="?(" "+f+" ").indexOf(c)>-1:b==="|="?f===c||f.substr(0,c.length+1)===c+"-":!1):!0}},CHILD:function(a,b,c,d){return a==="nth"?function(a){var b,e,f=a.parentNode;if(c===1&&d===0)return!0;if(f){e=0;for(b=f.firstChild;b;b=b.nextSibling)if(b.nodeType===1){e++;if(a===b)break}}return e-=d,e===c||e%c===0&&e/c>=0}:function(b){var c=b;switch(a){case"only":case"first":while(c=c.previousSibling)if(c.nodeType===1)return!1;if(a==="first")return!0;c=b;case"last":while(c=c.nextSibling)if(c.nodeType===1)return!1;return!0}}},PSEUDO:function(a,b){var c,d=e.pseudos[a]||e.setFilters[a.toLowerCase()]||bc.error("unsupported pseudo: "+a);return d[o]?d(b):d.length>1?(c=[a,a,"",b],e.setFilters.hasOwnProperty(a.toLowerCase())?z(function(a,c){var e,f=d(a,b),g=f.length;while(g--)e=y.call(a,f[g]),a[e]=!(c[e]=f[g])}):function(a){return d(a,0,c)}):d}},pseudos:{not:z(function(a){var b=[],c=[],d=i(a.replace(L,"$1"));return d[o]?z(function(a,b,c,e){var f,g=d(a,null,e,[]),h=a.length;while(h--)if(f=g[h])a[h]=!(b[h]=f)}):function(a,e,f){return b[0]=a,d(b,null,f,c),!c.pop()}}),has:z(function(a){return function(b){return bc(a,b).length>0}}),contains:z(function(a){return function(b){return(b.textContent||b.innerText||f(b)).indexOf(a)>-1}}),enabled:function(a){return a.disabled===!1},disabled:function(a){return a.disabled===!0},checked:function(a){var b=a.nodeName.toLowerCase();return b==="input"&&!!a.checked||b==="option"&&!!a.selected},selected:function(a){return a.parentNode&&a.parentNode.selectedIndex,a.selected===!0},parent:function(a){return!e.pseudos.empty(a)},empty:function(a){var b;a=a.firstChild;while(a){if(a.nodeName>"@"||(b=a.nodeType)===3||b===4)return!1;a=a.nextSibling}return!0},header:function(a){return T.test(a.nodeName)},text:function(a){var b,c;return a.nodeName.toLowerCase()==="input"&&(b=a.type)==="text"&&((c=a.getAttribute("type"))==null||c.toLowerCase()===b)},radio:bd("radio"),checkbox:bd("checkbox"),file:bd("file"),password:bd("password"),image:bd("image"),submit:be("submit"),reset:be("reset"),button:function(a){var b=a.nodeName.toLowerCase();return b==="input"&&a.type==="button"||b==="button"},input:function(a){return U.test(a.nodeName)},focus:function(a){var b=a.ownerDocument;return a===b.activeElement&&(!b.hasFocus||b.hasFocus())&&(!!a.type||!!a.href)},active:function(a){return a===a.ownerDocument.activeElement},first:bf(function(a,b,c){return[0]}),last:bf(function(a,b,c){return[b-1]}),eq:bf(function(a,b,c){return[c<0?c+b:c]}),even:bf(function(a,b,c){for(var d=0;d<b;d+=2)a.push(d);return a}),odd:bf(function(a,b,c){for(var d=1;d<b;d+=2)a.push(d);return a}),lt:bf(function(a,b,c){for(var d=c<0?c+b:c;--d>=0;)a.push(d);return a}),gt:bf(function(a,b,c){for(var d=c<0?c+b:c;++d<b;)a.push(d);return a})}},j=s.compareDocumentPosition?function(a,b){return a===b?(k=!0,0):(!a.compareDocumentPosition||!b.compareDocumentPosition?a.compareDocumentPosition:a.compareDocumentPosition(b)&4)?-1:1}:function(a,b){if(a===b)return k=!0,0;if(a.sourceIndex&&b.sourceIndex)return a.sourceIndex-b.sourceIndex;var c,d,e=[],f=[],g=a.parentNode,h=b.parentNode,i=g;if(g===h)return bg(a,b);if(!g)return-1;if(!h)return 1;while(i)e.unshift(i),i=i.parentNode;i=h;while(i)f.unshift(i),i=i.parentNode;c=e.length,d=f.length;for(var j=0;j<c&&j<d;j++)if(e[j]!==f[j])return bg(e[j],f[j]);return j===c?bg(a,f[j],-1):bg(e[j],b,1)},[0,0].sort(j),m=!k,bc.uniqueSort=function(a){var b,c=1;k=m,a.sort(j);if(k)for(;b=a[c];c++)b===a[c-1]&&a.splice(c--,1);return a},bc.error=function(a){throw new Error("Syntax error, unrecognized expression: "+a)},i=bc.compile=function(a,b){var c,d=[],e=[],f=D[o][a];if(!f){b||(b=bh(a)),c=b.length;while(c--)f=bm(b[c]),f[o]?d.push(f):e.push(f);f=D(a,bn(e,d))}return f},r.querySelectorAll&&function(){var a,b=bp,c=/'|\\/g,d=/\=[\x20\t\r\n\f]*([^'"\]]*)[\x20\t\r\n\f]*\]/g,e=[":focus"],f=[":active",":focus"],h=s.matchesSelector||s.mozMatchesSelector||s.webkitMatchesSelector||s.oMatchesSelector||s.msMatchesSelector;X(function(a){a.innerHTML="<select><option selected=''></option></select>",a.querySelectorAll("[selected]").length||e.push("\\["+E+"*(?:checked|disabled|ismap|multiple|readonly|selected|value)"),a.querySelectorAll(":checked").length||e.push(":checked")}),X(function(a){a.innerHTML="<p test=''></p>",a.querySelectorAll("[test^='']").length&&e.push("[*^$]="+E+"*(?:\"\"|'')"),a.innerHTML="<input type='hidden'/>",a.querySelectorAll(":enabled").length||e.push(":enabled",":disabled")}),e=new RegExp(e.join("|")),bp=function(a,d,f,g,h){if(!g&&!h&&(!e||!e.test(a))){var i,j,k=!0,l=o,m=d,n=d.nodeType===9&&a;if(d.nodeType===1&&d.nodeName.toLowerCase()!=="object"){i=bh(a),(k=d.getAttribute("id"))?l=k.replace(c,"\\$&"):d.setAttribute("id",l),l="[id='"+l+"'] ",j=i.length;while(j--)i[j]=l+i[j].join("");m=R.test(a)&&d.parentNode||d,n=i.join(",")}if(n)try{return w.apply(f,x.call(m.querySelectorAll(n),0)),f}catch(p){}finally{k||d.removeAttribute("id")}}return b(a,d,f,g,h)},h&&(X(function(b){a=h.call(b,"div");try{h.call(b,"[test!='']:sizzle"),f.push("!=",J)}catch(c){}}),f=new RegExp(f.join("|")),bc.matchesSelector=function(b,c){c=c.replace(d,"='$1']");if(!g(b)&&!f.test(c)&&(!e||!e.test(c)))try{var i=h.call(b,c);if(i||a||b.document&&b.document.nodeType!==11)return i}catch(j){}return bc(c,null,null,[b]).length>0})}(),e.pseudos.nth=e.pseudos.eq,e.filters=bq.prototype=e.pseudos,e.setFilters=new bq,bc.attr=p.attr,p.find=bc,p.expr=bc.selectors,p.expr[":"]=p.expr.pseudos,p.unique=bc.uniqueSort,p.text=bc.getText,p.isXMLDoc=bc.isXML,p.contains=bc.contains}(a);var bc=/Until$/,bd=/^(?:parents|prev(?:Until|All))/,be=/^.[^:#\[\.,]*$/,bf=p.expr.match.needsContext,bg={children:!0,contents:!0,next:!0,prev:!0};p.fn.extend({find:function(a){var b,c,d,e,f,g,h=this;if(typeof a!="string")return p(a).filter(function(){for(b=0,c=h.length;b<c;b++)if(p.contains(h[b],this))return!0});g=this.pushStack("","find",a);for(b=0,c=this.length;b<c;b++){d=g.length,p.find(a,this[b],g);if(b>0)for(e=d;e<g.length;e++)for(f=0;f<d;f++)if(g[f]===g[e]){g.splice(e--,1);break}}return g},has:function(a){var b,c=p(a,this),d=c.length;return this.filter(function(){for(b=0;b<d;b++)if(p.contains(this,c[b]))return!0})},not:function(a){return this.pushStack(bj(this,a,!1),"not",a)},filter:function(a){return this.pushStack(bj(this,a,!0),"filter",a)},is:function(a){return!!a&&(typeof a=="string"?bf.test(a)?p(a,this.context).index(this[0])>=0:p.filter(a,this).length>0:this.filter(a).length>0)},closest:function(a,b){var c,d=0,e=this.length,f=[],g=bf.test(a)||typeof a!="string"?p(a,b||this.context):0;for(;d<e;d++){c=this[d];while(c&&c.ownerDocument&&c!==b&&c.nodeType!==11){if(g?g.index(c)>-1:p.find.matchesSelector(c,a)){f.push(c);break}c=c.parentNode}}return f=f.length>1?p.unique(f):f,this.pushStack(f,"closest",a)},index:function(a){return a?typeof a=="string"?p.inArray(this[0],p(a)):p.inArray(a.jquery?a[0]:a,this):this[0]&&this[0].parentNode?this.prevAll().length:-1},add:function(a,b){var c=typeof a=="string"?p(a,b):p.makeArray(a&&a.nodeType?[a]:a),d=p.merge(this.get(),c);return this.pushStack(bh(c[0])||bh(d[0])?d:p.unique(d))},addBack:function(a){return this.add(a==null?this.prevObject:this.prevObject.filter(a))}}),p.fn.andSelf=p.fn.addBack,p.each({parent:function(a){var b=a.parentNode;return b&&b.nodeType!==11?b:null},parents:function(a){return p.dir(a,"parentNode")},parentsUntil:function(a,b,c){return p.dir(a,"parentNode",c)},next:function(a){return bi(a,"nextSibling")},prev:function(a){return bi(a,"previousSibling")},nextAll:function(a){return p.dir(a,"nextSibling")},prevAll:function(a){return p.dir(a,"previousSibling")},nextUntil:function(a,b,c){return p.dir(a,"nextSibling",c)},prevUntil:function(a,b,c){return p.dir(a,"previousSibling",c)},siblings:function(a){return p.sibling((a.parentNode||{}).firstChild,a)},children:function(a){return p.sibling(a.firstChild)},contents:function(a){return p.nodeName(a,"iframe")?a.contentDocument||a.contentWindow.document:p.merge([],a.childNodes)}},function(a,b){p.fn[a]=function(c,d){var e=p.map(this,b,c);return bc.test(a)||(d=c),d&&typeof d=="string"&&(e=p.filter(d,e)),e=this.length>1&&!bg[a]?p.unique(e):e,this.length>1&&bd.test(a)&&(e=e.reverse()),this.pushStack(e,a,k.call(arguments).join(","))}}),p.extend({filter:function(a,b,c){return c&&(a=":not("+a+")"),b.length===1?p.find.matchesSelector(b[0],a)?[b[0]]:[]:p.find.matches(a,b)},dir:function(a,c,d){var e=[],f=a[c];while(f&&f.nodeType!==9&&(d===b||f.nodeType!==1||!p(f).is(d)))f.nodeType===1&&e.push(f),f=f[c];return e},sibling:function(a,b){var c=[];for(;a;a=a.nextSibling)a.nodeType===1&&a!==b&&c.push(a);return c}});var bl="abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",bm=/ jQuery\d+="(?:null|\d+)"/g,bn=/^\s+/,bo=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,bp=/<([\w:]+)/,bq=/<tbody/i,br=/<|&#?\w+;/,bs=/<(?:script|style|link)/i,bt=/<(?:script|object|embed|option|style)/i,bu=new RegExp("<(?:"+bl+")[\\s/>]","i"),bv=/^(?:checkbox|radio)$/,bw=/checked\s*(?:[^=]|=\s*.checked.)/i,bx=/\/(java|ecma)script/i,by=/^\s*<!(?:\[CDATA\[|\-\-)|[\]\-]{2}>\s*$/g,bz={option:[1,"<select multiple='multiple'>","</select>"],legend:[1,"<fieldset>","</fieldset>"],thead:[1,"<table>","</table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],col:[2,"<table><tbody></tbody><colgroup>","</colgroup></table>"],area:[1,"<map>","</map>"],_default:[0,"",""]},bA=bk(e),bB=bA.appendChild(e.createElement("div"));bz.optgroup=bz.option,bz.tbody=bz.tfoot=bz.colgroup=bz.caption=bz.thead,bz.th=bz.td,p.support.htmlSerialize||(bz._default=[1,"X<div>","</div>"]),p.fn.extend({text:function(a){return p.access(this,function(a){return a===b?p.text(this):this.empty().append((this[0]&&this[0].ownerDocument||e).createTextNode(a))},null,a,arguments.length)},wrapAll:function(a){if(p.isFunction(a))return this.each(function(b){p(this).wrapAll(a.call(this,b))});if(this[0]){var b=p(a,this[0].ownerDocument).eq(0).clone(!0);this[0].parentNode&&b.insertBefore(this[0]),b.map(function(){var a=this;while(a.firstChild&&a.firstChild.nodeType===1)a=a.firstChild;return a}).append(this)}return this},wrapInner:function(a){return p.isFunction(a)?this.each(function(b){p(this).wrapInner(a.call(this,b))}):this.each(function(){var b=p(this),c=b.contents();c.length?c.wrapAll(a):b.append(a)})},wrap:function(a){var b=p.isFunction(a);return this.each(function(c){p(this).wrapAll(b?a.call(this,c):a)})},unwrap:function(){return this.parent().each(function(){p.nodeName(this,"body")||p(this).replaceWith(this.childNodes)}).end()},append:function(){return this.domManip(arguments,!0,function(a){(this.nodeType===1||this.nodeType===11)&&this.appendChild(a)})},prepend:function(){return this.domManip(arguments,!0,function(a){(this.nodeType===1||this.nodeType===11)&&this.insertBefore(a,this.firstChild)})},before:function(){if(!bh(this[0]))return this.domManip(arguments,!1,function(a){this.parentNode.insertBefore(a,this)});if(arguments.length){var a=p.clean(arguments);return this.pushStack(p.merge(a,this),"before",this.selector)}},after:function(){if(!bh(this[0]))return this.domManip(arguments,!1,function(a){this.parentNode.insertBefore(a,this.nextSibling)});if(arguments.length){var a=p.clean(arguments);return this.pushStack(p.merge(this,a),"after",this.selector)}},remove:function(a,b){var c,d=0;for(;(c=this[d])!=null;d++)if(!a||p.filter(a,[c]).length)!b&&c.nodeType===1&&(p.cleanData(c.getElementsByTagName("*")),p.cleanData([c])),c.parentNode&&c.parentNode.removeChild(c);return this},empty:function(){var a,b=0;for(;(a=this[b])!=null;b++){a.nodeType===1&&p.cleanData(a.getElementsByTagName("*"));while(a.firstChild)a.removeChild(a.firstChild)}return this},clone:function(a,b){return a=a==null?!1:a,b=b==null?a:b,this.map(function(){return p.clone(this,a,b)})},html:function(a){return p.access(this,function(a){var c=this[0]||{},d=0,e=this.length;if(a===b)return c.nodeType===1?c.innerHTML.replace(bm,""):b;if(typeof a=="string"&&!bs.test(a)&&(p.support.htmlSerialize||!bu.test(a))&&(p.support.leadingWhitespace||!bn.test(a))&&!bz[(bp.exec(a)||["",""])[1].toLowerCase()]){a=a.replace(bo,"<$1></$2>");try{for(;d<e;d++)c=this[d]||{},c.nodeType===1&&(p.cleanData(c.getElementsByTagName("*")),c.innerHTML=a);c=0}catch(f){}}c&&this.empty().append(a)},null,a,arguments.length)},replaceWith:function(a){return bh(this[0])?this.length?this.pushStack(p(p.isFunction(a)?a():a),"replaceWith",a):this:p.isFunction(a)?this.each(function(b){var c=p(this),d=c.html();c.replaceWith(a.call(this,b,d))}):(typeof a!="string"&&(a=p(a).detach()),this.each(function(){var b=this.nextSibling,c=this.parentNode;p(this).remove(),b?p(b).before(a):p(c).append(a)}))},detach:function(a){return this.remove(a,!0)},domManip:function(a,c,d){a=[].concat.apply([],a);var e,f,g,h,i=0,j=a[0],k=[],l=this.length;if(!p.support.checkClone&&l>1&&typeof j=="string"&&bw.test(j))return this.each(function(){p(this).domManip(a,c,d)});if(p.isFunction(j))return this.each(function(e){var f=p(this);a[0]=j.call(this,e,c?f.html():b),f.domManip(a,c,d)});if(this[0]){e=p.buildFragment(a,this,k),g=e.fragment,f=g.firstChild,g.childNodes.length===1&&(g=f);if(f){c=c&&p.nodeName(f,"tr");for(h=e.cacheable||l-1;i<l;i++)d.call(c&&p.nodeName(this[i],"table")?bC(this[i],"tbody"):this[i],i===h?g:p.clone(g,!0,!0))}g=f=null,k.length&&p.each(k,function(a,b){b.src?p.ajax?p.ajax({url:b.src,type:"GET",dataType:"script",async:!1,global:!1,"throws":!0}):p.error("no ajax"):p.globalEval((b.text||b.textContent||b.innerHTML||"").replace(by,"")),b.parentNode&&b.parentNode.removeChild(b)})}return this}}),p.buildFragment=function(a,c,d){var f,g,h,i=a[0];return c=c||e,c=!c.nodeType&&c[0]||c,c=c.ownerDocument||c,a.length===1&&typeof i=="string"&&i.length<512&&c===e&&i.charAt(0)==="<"&&!bt.test(i)&&(p.support.checkClone||!bw.test(i))&&(p.support.html5Clone||!bu.test(i))&&(g=!0,f=p.fragments[i],h=f!==b),f||(f=c.createDocumentFragment(),p.clean(a,c,f,d),g&&(p.fragments[i]=h&&f)),{fragment:f,cacheable:g}},p.fragments={},p.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(a,b){p.fn[a]=function(c){var d,e=0,f=[],g=p(c),h=g.length,i=this.length===1&&this[0].parentNode;if((i==null||i&&i.nodeType===11&&i.childNodes.length===1)&&h===1)return g[b](this[0]),this;for(;e<h;e++)d=(e>0?this.clone(!0):this).get(),p(g[e])[b](d),f=f.concat(d);return this.pushStack(f,a,g.selector)}}),p.extend({clone:function(a,b,c){var d,e,f,g;p.support.html5Clone||p.isXMLDoc(a)||!bu.test("<"+a.nodeName+">")?g=a.cloneNode(!0):(bB.innerHTML=a.outerHTML,bB.removeChild(g=bB.firstChild));if((!p.support.noCloneEvent||!p.support.noCloneChecked)&&(a.nodeType===1||a.nodeType===11)&&!p.isXMLDoc(a)){bE(a,g),d=bF(a),e=bF(g);for(f=0;d[f];++f)e[f]&&bE(d[f],e[f])}if(b){bD(a,g);if(c){d=bF(a),e=bF(g);for(f=0;d[f];++f)bD(d[f],e[f])}}return d=e=null,g},clean:function(a,b,c,d){var f,g,h,i,j,k,l,m,n,o,q,r,s=b===e&&bA,t=[];if(!b||typeof b.createDocumentFragment=="undefined")b=e;for(f=0;(h=a[f])!=null;f++){typeof h=="number"&&(h+="");if(!h)continue;if(typeof h=="string")if(!br.test(h))h=b.createTextNode(h);else{s=s||bk(b),l=b.createElement("div"),s.appendChild(l),h=h.replace(bo,"<$1></$2>"),i=(bp.exec(h)||["",""])[1].toLowerCase(),j=bz[i]||bz._default,k=j[0],l.innerHTML=j[1]+h+j[2];while(k--)l=l.lastChild;if(!p.support.tbody){m=bq.test(h),n=i==="table"&&!m?l.firstChild&&l.firstChild.childNodes:j[1]==="<table>"&&!m?l.childNodes:[];for(g=n.length-1;g>=0;--g)p.nodeName(n[g],"tbody")&&!n[g].childNodes.length&&n[g].parentNode.removeChild(n[g])}!p.support.leadingWhitespace&&bn.test(h)&&l.insertBefore(b.createTextNode(bn.exec(h)[0]),l.firstChild),h=l.childNodes,l.parentNode.removeChild(l)}h.nodeType?t.push(h):p.merge(t,h)}l&&(h=l=s=null);if(!p.support.appendChecked)for(f=0;(h=t[f])!=null;f++)p.nodeName(h,"input")?bG(h):typeof h.getElementsByTagName!="undefined"&&p.grep(h.getElementsByTagName("input"),bG);if(c){q=function(a){if(!a.type||bx.test(a.type))return d?d.push(a.parentNode?a.parentNode.removeChild(a):a):c.appendChild(a)};for(f=0;(h=t[f])!=null;f++)if(!p.nodeName(h,"script")||!q(h))c.appendChild(h),typeof h.getElementsByTagName!="undefined"&&(r=p.grep(p.merge([],h.getElementsByTagName("script")),q),t.splice.apply(t,[f+1,0].concat(r)),f+=r.length)}return t},cleanData:function(a,b){var c,d,e,f,g=0,h=p.expando,i=p.cache,j=p.support.deleteExpando,k=p.event.special;for(;(e=a[g])!=null;g++)if(b||p.acceptData(e)){d=e[h],c=d&&i[d];if(c){if(c.events)for(f in c.events)k[f]?p.event.remove(e,f):p.removeEvent(e,f,c.handle);i[d]&&(delete i[d],j?delete e[h]:e.removeAttribute?e.removeAttribute(h):e[h]=null,p.deletedIds.push(d))}}}}),function(){var a,b;p.uaMatch=function(a){a=a.toLowerCase();var b=/(chrome)[ \/]([\w.]+)/.exec(a)||/(webkit)[ \/]([\w.]+)/.exec(a)||/(opera)(?:.*version|)[ \/]([\w.]+)/.exec(a)||/(msie) ([\w.]+)/.exec(a)||a.indexOf("compatible")<0&&/(mozilla)(?:.*? rv:([\w.]+)|)/.exec(a)||[];return{browser:b[1]||"",version:b[2]||"0"}},a=p.uaMatch(g.userAgent),b={},a.browser&&(b[a.browser]=!0,b.version=a.version),b.chrome?b.webkit=!0:b.webkit&&(b.safari=!0),p.browser=b,p.sub=function(){function a(b,c){return new a.fn.init(b,c)}p.extend(!0,a,this),a.superclass=this,a.fn=a.prototype=this(),a.fn.constructor=a,a.sub=this.sub,a.fn.init=function c(c,d){return d&&d instanceof p&&!(d instanceof a)&&(d=a(d)),p.fn.init.call(this,c,d,b)},a.fn.init.prototype=a.fn;var b=a(e);return a}}();var bH,bI,bJ,bK=/alpha\([^)]*\)/i,bL=/opacity=([^)]*)/,bM=/^(top|right|bottom|left)$/,bN=/^(none|table(?!-c[ea]).+)/,bO=/^margin/,bP=new RegExp("^("+q+")(.*)$","i"),bQ=new RegExp("^("+q+")(?!px)[a-z%]+$","i"),bR=new RegExp("^([-+])=("+q+")","i"),bS={},bT={position:"absolute",visibility:"hidden",display:"block"},bU={letterSpacing:0,fontWeight:400},bV=["Top","Right","Bottom","Left"],bW=["Webkit","O","Moz","ms"],bX=p.fn.toggle;p.fn.extend({css:function(a,c){return p.access(this,function(a,c,d){return d!==b?p.style(a,c,d):p.css(a,c)},a,c,arguments.length>1)},show:function(){return b$(this,!0)},hide:function(){return b$(this)},toggle:function(a,b){var c=typeof a=="boolean";return p.isFunction(a)&&p.isFunction(b)?bX.apply(this,arguments):this.each(function(){(c?a:bZ(this))?p(this).show():p(this).hide()})}}),p.extend({cssHooks:{opacity:{get:function(a,b){if(b){var c=bH(a,"opacity");return c===""?"1":c}}}},cssNumber:{fillOpacity:!0,fontWeight:!0,lineHeight:!0,opacity:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{"float":p.support.cssFloat?"cssFloat":"styleFloat"},style:function(a,c,d,e){if(!a||a.nodeType===3||a.nodeType===8||!a.style)return;var f,g,h,i=p.camelCase(c),j=a.style;c=p.cssProps[i]||(p.cssProps[i]=bY(j,i)),h=p.cssHooks[c]||p.cssHooks[i];if(d===b)return h&&"get"in h&&(f=h.get(a,!1,e))!==b?f:j[c];g=typeof d,g==="string"&&(f=bR.exec(d))&&(d=(f[1]+1)*f[2]+parseFloat(p.css(a,c)),g="number");if(d==null||g==="number"&&isNaN(d))return;g==="number"&&!p.cssNumber[i]&&(d+="px");if(!h||!("set"in h)||(d=h.set(a,d,e))!==b)try{j[c]=d}catch(k){}},css:function(a,c,d,e){var f,g,h,i=p.camelCase(c);return c=p.cssProps[i]||(p.cssProps[i]=bY(a.style,i)),h=p.cssHooks[c]||p.cssHooks[i],h&&"get"in h&&(f=h.get(a,!0,e)),f===b&&(f=bH(a,c)),f==="normal"&&c in bU&&(f=bU[c]),d||e!==b?(g=parseFloat(f),d||p.isNumeric(g)?g||0:f):f},swap:function(a,b,c){var d,e,f={};for(e in b)f[e]=a.style[e],a.style[e]=b[e];d=c.call(a);for(e in b)a.style[e]=f[e];return d}}),a.getComputedStyle?bH=function(b,c){var d,e,f,g,h=a.getComputedStyle(b,null),i=b.style;return h&&(d=h[c],d===""&&!p.contains(b.ownerDocument,b)&&(d=p.style(b,c)),bQ.test(d)&&bO.test(c)&&(e=i.width,f=i.minWidth,g=i.maxWidth,i.minWidth=i.maxWidth=i.width=d,d=h.width,i.width=e,i.minWidth=f,i.maxWidth=g)),d}:e.documentElement.currentStyle&&(bH=function(a,b){var c,d,e=a.currentStyle&&a.currentStyle[b],f=a.style;return e==null&&f&&f[b]&&(e=f[b]),bQ.test(e)&&!bM.test(b)&&(c=f.left,d=a.runtimeStyle&&a.runtimeStyle.left,d&&(a.runtimeStyle.left=a.currentStyle.left),f.left=b==="fontSize"?"1em":e,e=f.pixelLeft+"px",f.left=c,d&&(a.runtimeStyle.left=d)),e===""?"auto":e}),p.each(["height","width"],function(a,b){p.cssHooks[b]={get:function(a,c,d){if(c)return a.offsetWidth===0&&bN.test(bH(a,"display"))?p.swap(a,bT,function(){return cb(a,b,d)}):cb(a,b,d)},set:function(a,c,d){return b_(a,c,d?ca(a,b,d,p.support.boxSizing&&p.css(a,"boxSizing")==="border-box"):0)}}}),p.support.opacity||(p.cssHooks.opacity={get:function(a,b){return bL.test((b&&a.currentStyle?a.currentStyle.filter:a.style.filter)||"")?.01*parseFloat(RegExp.$1)+"":b?"1":""},set:function(a,b){var c=a.style,d=a.currentStyle,e=p.isNumeric(b)?"alpha(opacity="+b*100+")":"",f=d&&d.filter||c.filter||"";c.zoom=1;if(b>=1&&p.trim(f.replace(bK,""))===""&&c.removeAttribute){c.removeAttribute("filter");if(d&&!d.filter)return}c.filter=bK.test(f)?f.replace(bK,e):f+" "+e}}),p(function(){p.support.reliableMarginRight||(p.cssHooks.marginRight={get:function(a,b){return p.swap(a,{display:"inline-block"},function(){if(b)return bH(a,"marginRight")})}}),!p.support.pixelPosition&&p.fn.position&&p.each(["top","left"],function(a,b){p.cssHooks[b]={get:function(a,c){if(c){var d=bH(a,b);return bQ.test(d)?p(a).position()[b]+"px":d}}}})}),p.expr&&p.expr.filters&&(p.expr.filters.hidden=function(a){return a.offsetWidth===0&&a.offsetHeight===0||!p.support.reliableHiddenOffsets&&(a.style&&a.style.display||bH(a,"display"))==="none"},p.expr.filters.visible=function(a){return!p.expr.filters.hidden(a)}),p.each({margin:"",padding:"",border:"Width"},function(a,b){p.cssHooks[a+b]={expand:function(c){var d,e=typeof c=="string"?c.split(" "):[c],f={};for(d=0;d<4;d++)f[a+bV[d]+b]=e[d]||e[d-2]||e[0];return f}},bO.test(a)||(p.cssHooks[a+b].set=b_)});var cd=/%20/g,ce=/\[\]$/,cf=/\r?\n/g,cg=/^(?:color|date|datetime|datetime-local|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,ch=/^(?:select|textarea)/i;p.fn.extend({serialize:function(){return p.param(this.serializeArray())},serializeArray:function(){return this.map(function(){return this.elements?p.makeArray(this.elements):this}).filter(function(){return this.name&&!this.disabled&&(this.checked||ch.test(this.nodeName)||cg.test(this.type))}).map(function(a,b){var c=p(this).val();return c==null?null:p.isArray(c)?p.map(c,function(a,c){return{name:b.name,value:a.replace(cf,"\r\n")}}):{name:b.name,value:c.replace(cf,"\r\n")}}).get()}}),p.param=function(a,c){var d,e=[],f=function(a,b){b=p.isFunction(b)?b():b==null?"":b,e[e.length]=encodeURIComponent(a)+"="+encodeURIComponent(b)};c===b&&(c=p.ajaxSettings&&p.ajaxSettings.traditional);if(p.isArray(a)||a.jquery&&!p.isPlainObject(a))p.each(a,function(){f(this.name,this.value)});else for(d in a)ci(d,a[d],c,f);return e.join("&").replace(cd,"+")};var cj,ck,cl=/#.*$/,cm=/^(.*?):[ \t]*([^\r\n]*)\r?$/mg,cn=/^(?:about|app|app\-storage|.+\-extension|file|res|widget):$/,co=/^(?:GET|HEAD)$/,cp=/^\/\//,cq=/\?/,cr=/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,cs=/([?&])_=[^&]*/,ct=/^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+)|)|)/,cu=p.fn.load,cv={},cw={},cx=["*/"]+["*"];try{ck=f.href}catch(cy){ck=e.createElement("a"),ck.href="",ck=ck.href}cj=ct.exec(ck.toLowerCase())||[],p.fn.load=function(a,c,d){if(typeof a!="string"&&cu)return cu.apply(this,arguments);if(!this.length)return this;var e,f,g,h=this,i=a.indexOf(" ");return i>=0&&(e=a.slice(i,a.length),a=a.slice(0,i)),p.isFunction(c)?(d=c,c=b):c&&typeof c=="object"&&(f="POST"),p.ajax({url:a,type:f,dataType:"html",data:c,complete:function(a,b){d&&h.each(d,g||[a.responseText,b,a])}}).done(function(a){g=arguments,h.html(e?p("<div>").append(a.replace(cr,"")).find(e):a)}),this},p.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "),function(a,b){p.fn[b]=function(a){return this.on(b,a)}}),p.each(["get","post"],function(a,c){p[c]=function(a,d,e,f){return p.isFunction(d)&&(f=f||e,e=d,d=b),p.ajax({type:c,url:a,data:d,success:e,dataType:f})}}),p.extend({getScript:function(a,c){return p.get(a,b,c,"script")},getJSON:function(a,b,c){return p.get(a,b,c,"json")},ajaxSetup:function(a,b){return b?cB(a,p.ajaxSettings):(b=a,a=p.ajaxSettings),cB(a,b),a},ajaxSettings:{url:ck,isLocal:cn.test(cj[1]),global:!0,type:"GET",contentType:"application/x-www-form-urlencoded; charset=UTF-8",processData:!0,async:!0,accepts:{xml:"application/xml, text/xml",html:"text/html",text:"text/plain",json:"application/json, text/javascript","*":cx},contents:{xml:/xml/,html:/html/,json:/json/},responseFields:{xml:"responseXML",text:"responseText"},converters:{"* text":a.String,"text html":!0,"text json":p.parseJSON,"text xml":p.parseXML},flatOptions:{context:!0,url:!0}},ajaxPrefilter:cz(cv),ajaxTransport:cz(cw),ajax:function(a,c){function y(a,c,f,i){var k,s,t,u,w,y=c;if(v===2)return;v=2,h&&clearTimeout(h),g=b,e=i||"",x.readyState=a>0?4:0,f&&(u=cC(l,x,f));if(a>=200&&a<300||a===304)l.ifModified&&(w=x.getResponseHeader("Last-Modified"),w&&(p.lastModified[d]=w),w=x.getResponseHeader("Etag"),w&&(p.etag[d]=w)),a===304?(y="notmodified",k=!0):(k=cD(l,u),y=k.state,s=k.data,t=k.error,k=!t);else{t=y;if(!y||a)y="error",a<0&&(a=0)}x.status=a,x.statusText=(c||y)+"",k?o.resolveWith(m,[s,y,x]):o.rejectWith(m,[x,y,t]),x.statusCode(r),r=b,j&&n.trigger("ajax"+(k?"Success":"Error"),[x,l,k?s:t]),q.fireWith(m,[x,y]),j&&(n.trigger("ajaxComplete",[x,l]),--p.active||p.event.trigger("ajaxStop"))}typeof a=="object"&&(c=a,a=b),c=c||{};var d,e,f,g,h,i,j,k,l=p.ajaxSetup({},c),m=l.context||l,n=m!==l&&(m.nodeType||m instanceof p)?p(m):p.event,o=p.Deferred(),q=p.Callbacks("once memory"),r=l.statusCode||{},t={},u={},v=0,w="canceled",x={readyState:0,setRequestHeader:function(a,b){if(!v){var c=a.toLowerCase();a=u[c]=u[c]||a,t[a]=b}return this},getAllResponseHeaders:function(){return v===2?e:null},getResponseHeader:function(a){var c;if(v===2){if(!f){f={};while(c=cm.exec(e))f[c[1].toLowerCase()]=c[2]}c=f[a.toLowerCase()]}return c===b?null:c},overrideMimeType:function(a){return v||(l.mimeType=a),this},abort:function(a){return a=a||w,g&&g.abort(a),y(0,a),this}};o.promise(x),x.success=x.done,x.error=x.fail,x.complete=q.add,x.statusCode=function(a){if(a){var b;if(v<2)for(b in a)r[b]=[r[b],a[b]];else b=a[x.status],x.always(b)}return this},l.url=((a||l.url)+"").replace(cl,"").replace(cp,cj[1]+"//"),l.dataTypes=p.trim(l.dataType||"*").toLowerCase().split(s),l.crossDomain==null&&(i=ct.exec(l.url.toLowerCase())||!1,l.crossDomain=i&&i.join(":")+(i[3]?"":i[1]==="http:"?80:443)!==cj.join(":")+(cj[3]?"":cj[1]==="http:"?80:443)),l.data&&l.processData&&typeof l.data!="string"&&(l.data=p.param(l.data,l.traditional)),cA(cv,l,c,x);if(v===2)return x;j=l.global,l.type=l.type.toUpperCase(),l.hasContent=!co.test(l.type),j&&p.active++===0&&p.event.trigger("ajaxStart");if(!l.hasContent){l.data&&(l.url+=(cq.test(l.url)?"&":"?")+l.data,delete l.data),d=l.url;if(l.cache===!1){var z=p.now(),A=l.url.replace(cs,"$1_="+z);l.url=A+(A===l.url?(cq.test(l.url)?"&":"?")+"_="+z:"")}}(l.data&&l.hasContent&&l.contentType!==!1||c.contentType)&&x.setRequestHeader("Content-Type",l.contentType),l.ifModified&&(d=d||l.url,p.lastModified[d]&&x.setRequestHeader("If-Modified-Since",p.lastModified[d]),p.etag[d]&&x.setRequestHeader("If-None-Match",p.etag[d])),x.setRequestHeader("Accept",l.dataTypes[0]&&l.accepts[l.dataTypes[0]]?l.accepts[l.dataTypes[0]]+(l.dataTypes[0]!=="*"?", "+cx+"; q=0.01":""):l.accepts["*"]);for(k in l.headers)x.setRequestHeader(k,l.headers[k]);if(!l.beforeSend||l.beforeSend.call(m,x,l)!==!1&&v!==2){w="abort";for(k in{success:1,error:1,complete:1})x[k](l[k]);g=cA(cw,l,c,x);if(!g)y(-1,"No Transport");else{x.readyState=1,j&&n.trigger("ajaxSend",[x,l]),l.async&&l.timeout>0&&(h=setTimeout(function(){x.abort("timeout")},l.timeout));try{v=1,g.send(t,y)}catch(B){if(v<2)y(-1,B);else throw B}}return x}return x.abort()},active:0,lastModified:{},etag:{}});var cE=[],cF=/\?/,cG=/(=)\?(?=&|$)|\?\?/,cH=p.now();p.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var a=cE.pop()||p.expando+"_"+cH++;return this[a]=!0,a}}),p.ajaxPrefilter("json jsonp",function(c,d,e){var f,g,h,i=c.data,j=c.url,k=c.jsonp!==!1,l=k&&cG.test(j),m=k&&!l&&typeof i=="string"&&!(c.contentType||"").indexOf("application/x-www-form-urlencoded")&&cG.test(i);if(c.dataTypes[0]==="jsonp"||l||m)return f=c.jsonpCallback=p.isFunction(c.jsonpCallback)?c.jsonpCallback():c.jsonpCallback,g=a[f],l?c.url=j.replace(cG,"$1"+f):m?c.data=i.replace(cG,"$1"+f):k&&(c.url+=(cF.test(j)?"&":"?")+c.jsonp+"="+f),c.converters["script json"]=function(){return h||p.error(f+" was not called"),h[0]},c.dataTypes[0]="json",a[f]=function(){h=arguments},e.always(function(){a[f]=g,c[f]&&(c.jsonpCallback=d.jsonpCallback,cE.push(f)),h&&p.isFunction(g)&&g(h[0]),h=g=b}),"script"}),p.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/javascript|ecmascript/},converters:{"text script":function(a){return p.globalEval(a),a}}}),p.ajaxPrefilter("script",function(a){a.cache===b&&(a.cache=!1),a.crossDomain&&(a.type="GET",a.global=!1)}),p.ajaxTransport("script",function(a){if(a.crossDomain){var c,d=e.head||e.getElementsByTagName("head")[0]||e.documentElement;return{send:function(f,g){c=e.createElement("script"),c.async="async",a.scriptCharset&&(c.charset=a.scriptCharset),c.src=a.url,c.onload=c.onreadystatechange=function(a,e){if(e||!c.readyState||/loaded|complete/.test(c.readyState))c.onload=c.onreadystatechange=null,d&&c.parentNode&&d.removeChild(c),c=b,e||g(200,"success")},d.insertBefore(c,d.firstChild)},abort:function(){c&&c.onload(0,1)}}}});var cI,cJ=a.ActiveXObject?function(){for(var a in cI)cI[a](0,1)}:!1,cK=0;p.ajaxSettings.xhr=a.ActiveXObject?function(){return!this.isLocal&&cL()||cM()}:cL,function(a){p.extend(p.support,{ajax:!!a,cors:!!a&&"withCredentials"in a})}(p.ajaxSettings.xhr()),p.support.ajax&&p.ajaxTransport(function(c){if(!c.crossDomain||p.support.cors){var d;return{send:function(e,f){var g,h,i=c.xhr();c.username?i.open(c.type,c.url,c.async,c.username,c.password):i.open(c.type,c.url,c.async);if(c.xhrFields)for(h in c.xhrFields)i[h]=c.xhrFields[h];c.mimeType&&i.overrideMimeType&&i.overrideMimeType(c.mimeType),!c.crossDomain&&!e["X-Requested-With"]&&(e["X-Requested-With"]="XMLHttpRequest");try{for(h in e)i.setRequestHeader(h,e[h])}catch(j){}i.send(c.hasContent&&c.data||null),d=function(a,e){var h,j,k,l,m;try{if(d&&(e||i.readyState===4)){d=b,g&&(i.onreadystatechange=p.noop,cJ&&delete cI[g]);if(e)i.readyState!==4&&i.abort();else{h=i.status,k=i.getAllResponseHeaders(),l={},m=i.responseXML,m&&m.documentElement&&(l.xml=m);try{l.text=i.responseText}catch(a){}try{j=i.statusText}catch(n){j=""}!h&&c.isLocal&&!c.crossDomain?h=l.text?200:404:h===1223&&(h=204)}}}catch(o){e||f(-1,o)}l&&f(h,j,l,k)},c.async?i.readyState===4?setTimeout(d,0):(g=++cK,cJ&&(cI||(cI={},p(a).unload(cJ)),cI[g]=d),i.onreadystatechange=d):d()},abort:function(){d&&d(0,1)}}}});var cN,cO,cP=/^(?:toggle|show|hide)$/,cQ=new RegExp("^(?:([-+])=|)("+q+")([a-z%]*)$","i"),cR=/queueHooks$/,cS=[cY],cT={"*":[function(a,b){var c,d,e=this.createTween(a,b),f=cQ.exec(b),g=e.cur(),h=+g||0,i=1,j=20;if(f){c=+f[2],d=f[3]||(p.cssNumber[a]?"":"px");if(d!=="px"&&h){h=p.css(e.elem,a,!0)||c||1;do i=i||".5",h=h/i,p.style(e.elem,a,h+d);while(i!==(i=e.cur()/g)&&i!==1&&--j)}e.unit=d,e.start=h,e.end=f[1]?h+(f[1]+1)*c:c}return e}]};p.Animation=p.extend(cW,{tweener:function(a,b){p.isFunction(a)?(b=a,a=["*"]):a=a.split(" ");var c,d=0,e=a.length;for(;d<e;d++)c=a[d],cT[c]=cT[c]||[],cT[c].unshift(b)},prefilter:function(a,b){b?cS.unshift(a):cS.push(a)}}),p.Tween=cZ,cZ.prototype={constructor:cZ,init:function(a,b,c,d,e,f){this.elem=a,this.prop=c,this.easing=e||"swing",this.options=b,this.start=this.now=this.cur(),this.end=d,this.unit=f||(p.cssNumber[c]?"":"px")},cur:function(){var a=cZ.propHooks[this.prop];return a&&a.get?a.get(this):cZ.propHooks._default.get(this)},run:function(a){var b,c=cZ.propHooks[this.prop];return this.options.duration?this.pos=b=p.easing[this.easing](a,this.options.duration*a,0,1,this.options.duration):this.pos=b=a,this.now=(this.end-this.start)*b+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),c&&c.set?c.set(this):cZ.propHooks._default.set(this),this}},cZ.prototype.init.prototype=cZ.prototype,cZ.propHooks={_default:{get:function(a){var b;return a.elem[a.prop]==null||!!a.elem.style&&a.elem.style[a.prop]!=null?(b=p.css(a.elem,a.prop,!1,""),!b||b==="auto"?0:b):a.elem[a.prop]},set:function(a){p.fx.step[a.prop]?p.fx.step[a.prop](a):a.elem.style&&(a.elem.style[p.cssProps[a.prop]]!=null||p.cssHooks[a.prop])?p.style(a.elem,a.prop,a.now+a.unit):a.elem[a.prop]=a.now}}},cZ.propHooks.scrollTop=cZ.propHooks.scrollLeft={set:function(a){a.elem.nodeType&&a.elem.parentNode&&(a.elem[a.prop]=a.now)}},p.each(["toggle","show","hide"],function(a,b){var c=p.fn[b];p.fn[b]=function(d,e,f){return d==null||typeof d=="boolean"||!a&&p.isFunction(d)&&p.isFunction(e)?c.apply(this,arguments):this.animate(c$(b,!0),d,e,f)}}),p.fn.extend({fadeTo:function(a,b,c,d){return this.filter(bZ).css("opacity",0).show().end().animate({opacity:b},a,c,d)},animate:function(a,b,c,d){var e=p.isEmptyObject(a),f=p.speed(b,c,d),g=function(){var b=cW(this,p.extend({},a),f);e&&b.stop(!0)};return e||f.queue===!1?this.each(g):this.queue(f.queue,g)},stop:function(a,c,d){var e=function(a){var b=a.stop;delete a.stop,b(d)};return typeof a!="string"&&(d=c,c=a,a=b),c&&a!==!1&&this.queue(a||"fx",[]),this.each(function(){var b=!0,c=a!=null&&a+"queueHooks",f=p.timers,g=p._data(this);if(c)g[c]&&g[c].stop&&e(g[c]);else for(c in g)g[c]&&g[c].stop&&cR.test(c)&&e(g[c]);for(c=f.length;c--;)f[c].elem===this&&(a==null||f[c].queue===a)&&(f[c].anim.stop(d),b=!1,f.splice(c,1));(b||!d)&&p.dequeue(this,a)})}}),p.each({slideDown:c$("show"),slideUp:c$("hide"),slideToggle:c$("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(a,b){p.fn[a]=function(a,c,d){return this.animate(b,a,c,d)}}),p.speed=function(a,b,c){var d=a&&typeof a=="object"?p.extend({},a):{complete:c||!c&&b||p.isFunction(a)&&a,duration:a,easing:c&&b||b&&!p.isFunction(b)&&b};d.duration=p.fx.off?0:typeof d.duration=="number"?d.duration:d.duration in p.fx.speeds?p.fx.speeds[d.duration]:p.fx.speeds._default;if(d.queue==null||d.queue===!0)d.queue="fx";return d.old=d.complete,d.complete=function(){p.isFunction(d.old)&&d.old.call(this),d.queue&&p.dequeue(this,d.queue)},d},p.easing={linear:function(a){return a},swing:function(a){return.5-Math.cos(a*Math.PI)/2}},p.timers=[],p.fx=cZ.prototype.init,p.fx.tick=function(){var a,b=p.timers,c=0;for(;c<b.length;c++)a=b[c],!a()&&b[c]===a&&b.splice(c--,1);b.length||p.fx.stop()},p.fx.timer=function(a){a()&&p.timers.push(a)&&!cO&&(cO=setInterval(p.fx.tick,p.fx.interval))},p.fx.interval=13,p.fx.stop=function(){clearInterval(cO),cO=null},p.fx.speeds={slow:600,fast:200,_default:400},p.fx.step={},p.expr&&p.expr.filters&&(p.expr.filters.animated=function(a){return p.grep(p.timers,function(b){return a===b.elem}).length});var c_=/^(?:body|html)$/i;p.fn.offset=function(a){if(arguments.length)return a===b?this:this.each(function(b){p.offset.setOffset(this,a,b)});var c,d,e,f,g,h,i,j={top:0,left:0},k=this[0],l=k&&k.ownerDocument;if(!l)return;return(d=l.body)===k?p.offset.bodyOffset(k):(c=l.documentElement,p.contains(c,k)?(typeof k.getBoundingClientRect!="undefined"&&(j=k.getBoundingClientRect()),e=da(l),f=c.clientTop||d.clientTop||0,g=c.clientLeft||d.clientLeft||0,h=e.pageYOffset||c.scrollTop,i=e.pageXOffset||c.scrollLeft,{top:j.top+h-f,left:j.left+i-g}):j)},p.offset={bodyOffset:function(a){var b=a.offsetTop,c=a.offsetLeft;return p.support.doesNotIncludeMarginInBodyOffset&&(b+=parseFloat(p.css(a,"marginTop"))||0,c+=parseFloat(p.css(a,"marginLeft"))||0),{top:b,left:c}},setOffset:function(a,b,c){var d=p.css(a,"position");d==="static"&&(a.style.position="relative");var e=p(a),f=e.offset(),g=p.css(a,"top"),h=p.css(a,"left"),i=(d==="absolute"||d==="fixed")&&p.inArray("auto",[g,h])>-1,j={},k={},l,m;i?(k=e.position(),l=k.top,m=k.left):(l=parseFloat(g)||0,m=parseFloat(h)||0),p.isFunction(b)&&(b=b.call(a,c,f)),b.top!=null&&(j.top=b.top-f.top+l),b.left!=null&&(j.left=b.left-f.left+m),"using"in b?b.using.call(a,j):e.css(j)}},p.fn.extend({position:function(){if(!this[0])return;var a=this[0],b=this.offsetParent(),c=this.offset(),d=c_.test(b[0].nodeName)?{top:0,left:0}:b.offset();return c.top-=parseFloat(p.css(a,"marginTop"))||0,c.left-=parseFloat(p.css(a,"marginLeft"))||0,d.top+=parseFloat(p.css(b[0],"borderTopWidth"))||0,d.left+=parseFloat(p.css(b[0],"borderLeftWidth"))||0,{top:c.top-d.top,left:c.left-d.left}},offsetParent:function(){return this.map(function(){var a=this.offsetParent||e.body;while(a&&!c_.test(a.nodeName)&&p.css(a,"position")==="static")a=a.offsetParent;return a||e.body})}}),p.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(a,c){var d=/Y/.test(c);p.fn[a]=function(e){return p.access(this,function(a,e,f){var g=da(a);if(f===b)return g?c in g?g[c]:g.document.documentElement[e]:a[e];g?g.scrollTo(d?p(g).scrollLeft():f,d?f:p(g).scrollTop()):a[e]=f},a,e,arguments.length,null)}}),p.each({Height:"height",Width:"width"},function(a,c){p.each({padding:"inner"+a,content:c,"":"outer"+a},function(d,e){p.fn[e]=function(e,f){var g=arguments.length&&(d||typeof e!="boolean"),h=d||(e===!0||f===!0?"margin":"border");return p.access(this,function(c,d,e){var f;return p.isWindow(c)?c.document.documentElement["client"+a]:c.nodeType===9?(f=c.documentElement,Math.max(c.body["scroll"+a],f["scroll"+a],c.body["offset"+a],f["offset"+a],f["client"+a])):e===b?p.css(c,d,e,h):p.style(c,d,e,h)},c,g?e:b,g,null)}})}),a.jQuery=a.$=p,typeof define=="function"&&define.amd&&define.amd.jQuery&&define("jquery",[],function(){return p})})(window);
\ No newline at end of file
