[WebUI] Update extjs to 3.4.1.1

Better late than never...

http://cdn.sencha.com/ext/commercial/3.4.1.1/release-notes.html

.gitattributes

@@ -2,3 +2,4 @@
 .gitmodules export-ignore
 .gitignore export-ignore
 *.py diff=python
+ext-all.js diff=minjs

deluge/ui/web/css/ext-all-notheme.css

@@ -1,8 +1,22 @@
-/*!
+/*
- * Ext JS Library 3.4.0
+This file is part of Ext JS 3.4
- * Copyright(c) 2006-2011 Sencha Inc.
+
- * licensing@sencha.com
+Copyright (c) 2011-2013 Sencha Inc
- * http://www.sencha.com/license
+
+Contact:  http://www.sencha.com/contact
+
+GNU General Public License Usage
+This file may be used under the terms of the GNU General Public License version 3.0 as
+published by the Free Software Foundation and appearing in the file LICENSE included in the
+packaging of this file.
+
+Please review the following information to ensure the GNU General Public License version 3.0
+requirements will be met: http://www.gnu.org/copyleft/gpl.html.
+
+If you are unsure which license is appropriate for your use, please contact the sales department
+at http://www.sencha.com/contact.
+
+Build date: 2013-04-03 15:07:25
 */
 html,body,div,dl,dt,dd,ul,ol,li,h1,h2,h3,h4,h5,h6,pre,form,fieldset,input,p,blockquote,th,td{margin:0;padding:0;}img,body,html{border:0;}address,caption,cite,code,dfn,em,strong,th,var{font-style:normal;font-weight:normal;}ol,ul {list-style:none;}caption,th {text-align:left;}h1,h2,h3,h4,h5,h6{font-size:100%;}q:before,q:after{content:'';}
 
@@ -105,9 +119,12 @@ html,body,div,dl,dt,dd,ul,ol,li,h1,h2,h3,h4,h5,h6,pre,form,fieldset,input,p,bloc
 }
 
 .x-unselectable, .x-unselectable * {
-    -moz-user-select: none;
+    user-select: none;
-    -khtml-user-select: none;
+    -o-user-select: none;
-    -webkit-user-select:ignore;
+    -ms-user-select: none;
+    -moz-user-select: -moz-none;
+    -webkit-user-select: none;
+    cursor:default;
 }
 
 .x-repaint {
@@ -657,27 +674,28 @@ ul.x-tab-strip li.x-tab-edge {
 }
 
 /*
- * Horrible hack for IE8 in quirks mode
+ * For IE8/9 in quirks mode
  */
 .ext-ie8 .x-tab-strip li {
     position: relative;
 }
-.ext-border-box .ext-ie8 .x-tab-strip-top .x-tab-right {
+.ext-border-box .ext-ie8 .x-tab-strip-top .x-tab-right, .ext-border-box .ext-ie9 .x-tab-strip-top .x-tab-right {
     top: 1px;
 }
-.ext-ie8 .x-tab-strip-top {
+.ext-ie8 .x-tab-strip-top, .ext-ie9 .x-tab-strip-top {
-    padding-top: 1;
+    padding-top: 1px;
 }
-.ext-border-box .ext-ie8 .x-tab-strip-top {
+.ext-border-box .ext-ie8 .x-tab-strip-top, .ext-border-box .ext-ie9 .x-tab-strip-top {
     padding-top: 0;
 }
-.ext-ie8 .x-tab-strip .x-tab-strip-closable a.x-tab-strip-close {
+.ext-ie8 .x-tab-strip .x-tab-strip-closable a.x-tab-strip-close, .ext-ie9 .x-tab-strip .x-tab-strip-closable a.x-tab-strip-close {
     top:3px;
 }
-.ext-border-box .ext-ie8 .x-tab-strip .x-tab-strip-closable a.x-tab-strip-close {
+.ext-border-box .ext-ie8 .x-tab-strip .x-tab-strip-closable a.x-tab-strip-close,
+.ext-border-box .ext-ie9 .x-tab-strip .x-tab-strip-closable a.x-tab-strip-close {
     top:4px;
 }
-.ext-ie8 .x-tab-strip-bottom .x-tab-right{
+.ext-ie8 .x-tab-strip-bottom .x-tab-right, .ext-ie9 .x-tab-strip-bottom .x-tab-right{
     top:0;
 }
 
@@ -2685,6 +2703,11 @@ a.x-grid3-hd-btn:hover {
     top:-1px;
 }
 
+.x-grid-editor .x-form-check-wrap {
+    text-align: center;
+    margin-top: -4px;
+}
+
 .ext-ie .x-props-grid .x-editor .x-form-text {
     position:static;
     top:0;

deluge/ui/web/js/extjs/ext-base-debug.js

@@ -1,8 +1,22 @@
-/*!
+/*
- * Ext JS Library 3.4.0
+This file is part of Ext JS 3.4
- * Copyright(c) 2006-2011 Sencha Inc.
+
- * licensing@sencha.com
+Copyright (c) 2011-2013 Sencha Inc
- * http://www.sencha.com/license
+
+Contact:  http://www.sencha.com/contact
+
+GNU General Public License Usage
+This file may be used under the terms of the GNU General Public License version 3.0 as
+published by the Free Software Foundation and appearing in the file LICENSE included in the
+packaging of this file.
+
+Please review the following information to ensure the GNU General Public License version 3.0
+requirements will be met: http://www.gnu.org/copyleft/gpl.html.
+
+If you are unsure which license is appropriate for your use, please contact the sales department
+at http://www.sencha.com/contact.
+
+Build date: 2013-04-03 15:07:25
 */
 // for old browsers
 window.undefined = window.undefined;
@@ -18,11 +32,11 @@ Ext = {
      * The version of the framework
      * @type String
      */
-    version : '3.4.0',
+    version : '3.4.1.1',
     versionDetail : {
         major : 3,
         minor : 4,
-        patch : 0
+        patch : 1.1
     }
 };
 
@@ -65,19 +79,81 @@ Ext.apply = function(o, c, defaults){
         isSafari3 = isSafari && check(/version\/3/),
         isSafari4 = isSafari && check(/version\/4/),
         isIE = !isOpera && check(/msie/),
-        isIE7 = isIE && (check(/msie 7/) || docMode == 7),
+        isIE7 = isIE && ((check(/msie 7/) && docMode != 8 && docMode != 9 && docMode != 10) || docMode == 7),
-        isIE8 = isIE && (check(/msie 8/) && docMode != 7),
+        isIE8 = isIE && ((check(/msie 8/) && docMode != 7 && docMode != 9 && docMode != 10) || docMode == 8),
-        isIE9 = isIE && check(/msie 9/),
+        isIE9 = isIE && ((check(/msie 9/) && docMode != 7 && docMode != 8 && docMode != 10) || docMode == 9),
-        isIE6 = isIE && !isIE7 && !isIE8 && !isIE9,
+        isIE10 = isIE && ((check(/msie 10/) && docMode != 7 && docMode != 8 && docMode != 9) || docMode == 10),
+        isIE6 = isIE && check(/msie 6/),
+        isIE9m = isIE && (isIE6 || isIE7 || isIE8 || isIE9),
         isGecko = !isWebKit && check(/gecko/),
         isGecko2 = isGecko && check(/rv:1\.8/),
         isGecko3 = isGecko && check(/rv:1\.9/),
-        isBorderBox = isIE && !isStrict,
+        isBorderBox = isIE9m && !isStrict,
         isWindows = check(/windows|win32/),
         isMac = check(/macintosh|mac os x/),
         isAir = check(/adobeair/),
         isLinux = check(/linux/),
-        isSecure = /^https/i.test(window.location.protocol);
+        isSecure = /^https/i.test(window.location.protocol),
+        noArgs = [],
+        nonEnumerables = [],
+        emptyFn = Ext.emptyFn,
+        t = Ext.apply({}, {
+            constructor: emptyFn,
+            toString: emptyFn,
+            valueOf: emptyFn
+        }),
+        callOverrideParent = function () {
+            var method = callOverrideParent.caller.caller; // skip callParent (our caller)
+            return method.$owner.prototype[method.$name].apply(this, arguments);
+        };
+
+    if (t.constructor !== emptyFn) {
+        nonEnumerables.push('constructor');
+    }
+    if (t.toString !== emptyFn) {
+        nonEnumerables.push('toString');
+    }
+    if (t.valueOf !== emptyFn) {
+        nonEnumerables.push('valueOf');
+    }
+    if (!nonEnumerables.length) {
+        nonEnumerables = null;
+    }
+
+    // Create the abstract Base class to provide an empty constructor and callParent implementations
+    function Base () {
+        //
+    }
+
+    Ext.apply(Base, {
+        $isClass: true,
+
+        callParent: function (args) {
+            var method;
+
+            // This code is intentionally inlined for the least number of debugger stepping
+            return (method = this.callParent.caller) && (method.$previous ||
+                ((method = method.$owner ? method : method.caller) &&
+                        method.$owner.superclass.self[method.$name])).apply(this, args || noArgs);
+        }
+    });
+
+    Base.prototype = {
+        constructor: function() {
+        },
+        callParent: function(args) {
+            // NOTE: this code is deliberately as few expressions (and no function calls)
+            // as possible so that a debugger can skip over this noise with the minimum number
+            // of steps. Basically, just hit Step Into until you are where you really wanted
+            // to be.
+            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);
+        }
+    };
 
     // remove css image flicker
     if(isIE6){
@@ -270,29 +346,375 @@ MyGridPanel = Ext.extend(Ext.grid.GridPanel, {
             };
         }(),
 
-        /**
+        global: (function () {
-         * Adds a list of functions to the prototype of an existing class, overwriting any existing methods with the same name.
+            return this;
-         * Usage:<pre><code>
+        })(),
-Ext.override(MyClass, {
+
-    newMethod1: function(){
+        Base: Base,
-        // etc.
+
-    },
+        namespaceCache: {},
-    newMethod2: function(foo){
+
-        // etc.
+        createNamespace: function (namespaceOrClass, isClass) {
+            var cache = Ext.namespaceCache,
+                namespace = isClass ? namespaceOrClass.substring(0, namespaceOrClass.lastIndexOf('.'))
+                            : namespaceOrClass,
+                ns = cache[namespace],
+                i, n, part, parts, partials;
+
+            if (!ns) {
+                ns = Ext.global;
+                if (namespace) {
+                    partials = [];
+                    parts = namespace.split('.');
+
+                    for (i = 0, n = parts.length; i < n; ++i) {
+                        part = parts[i];
+
+                        ns = ns[part] || (ns[part] = {});
+                        partials.push(part);
+
+                        cache[partials.join('.')] = ns; // build up prefixes as we go
                     }
-});
+                }
-</code></pre>
+            }
-         * @param {Object} origclass The class to override
+
-         * @param {Object} overrides The list of functions to add to origClass.  This should be specified as an object literal
+            return ns;
-         * containing one or more methods.
+        },
+
+        getClassByName: function (className) {
+            var parts = className.split('.'),
+                cls = Ext.global,
+                n = parts.length,
+                i;
+
+            for (i = 0; cls && i < n; ++i) {
+                cls = cls[parts[i]];
+            }
+
+            return cls || null;
+        },
+
+        addMembers: function (cls, target, members, handleNonEnumerables) {
+            var i, name, member;
+
+            for (name in members) {
+                if (members.hasOwnProperty(name)) {
+                    member = members[name];
+                    if (typeof member == 'function') {
+                        member.$owner = cls;
+                        member.$name = name;
+                    }
+
+                    target[name] = member;
+                }
+            }
+
+            if (handleNonEnumerables && nonEnumerables) {
+                for (i = nonEnumerables.length; i-- > 0; ) {
+                    name = nonEnumerables[i];
+                    if (members.hasOwnProperty(name)) {
+                        member = members[name];
+                        if (typeof member == 'function') {
+                            member.$owner = cls;
+                            member.$name = name;
+                        }
+
+                        target[name] = member;
+                    }
+                }
+            }
+        },
+
+        /**
+         * @method
+         * Defines a class or override. A basic class is defined like this:
+         *
+         *      Ext.define('My.awesome.Class', {
+         *          someProperty: 'something',
+         *
+         *          someMethod: function(s) {
+         *              alert(s + this.someProperty);
+         *          }
+         *
+         *          ...
+         *      });
+         *
+         *      var obj = new My.awesome.Class();
+         *
+         *      obj.someMethod('Say '); // alerts 'Say something'
+         *
+         * To create an anonymous class, pass `null` for the `className`:
+         *
+         *      Ext.define(null, {
+         *          constructor: function () {
+         *              // ...
+         *          }
+         *      });
+         *
+         * In some cases, it is helpful to create a nested scope to contain some private
+         * properties. The best way to do this is to pass a function instead of an object
+         * as the second parameter. This function will be called to produce the class
+         * body:
+         *
+         *      Ext.define('MyApp.foo.Bar', function () {
+         *          var id = 0;
+         *
+         *          return {
+         *              nextId: function () {
+         *                  return ++id;
+         *              }
+         *          };
+         *      });
+         *
+         * When using this form of `Ext.define`, the function is passed a reference to its
+         * class. This can be used as an efficient way to access any static properties you
+         * may have:
+         *
+         *      Ext.define('MyApp.foo.Bar', function (Bar) {
+         *          return {
+         *              statics: {
+         *                  staticMethod: function () {
+         *                      // ...
+         *                  }
+         *              },
+         *
+         *              method: function () {
+         *                  return Bar.staticMethod();
+         *              }
+         *          };
+         *      });
+         *
+         * To define an override, include the `override` property. The content of an
+         * override is aggregated with the specified class in order to extend or modify
+         * that class. This can be as simple as setting default property values or it can
+         * extend and/or replace methods. This can also extend the statics of the class.
+         *
+         * One use for an override is to break a large class into manageable pieces.
+         *
+         *      // File: /src/app/Panel.js
+         *
+         *      Ext.define('My.app.Panel', {
+         *          extend: 'Ext.panel.Panel',
+         *
+         *          constructor: function (config) {
+         *              this.callParent(arguments); // calls Ext.panel.Panel's constructor
+         *              //...
+         *          },
+         *
+         *          statics: {
+         *              method: function () {
+         *                  return 'abc';
+         *              }
+         *          }
+         *      });
+         *
+         *      // File: /src/app/PanelPart2.js
+         *      Ext.define('My.app.PanelPart2', {
+         *          override: 'My.app.Panel',
+         *
+         *          constructor: function (config) {
+         *              this.callParent(arguments); // calls My.app.Panel's constructor
+         *              //...
+         *          }
+         *      });
+         *
+         * Another use of overrides is to provide optional parts of classes that can be
+         * independently required. In this case, the class may even be unaware of the
+         * override altogether.
+         *
+         *      Ext.define('My.ux.CoolTip', {
+         *          override: 'Ext.tip.ToolTip',
+         *
+         *          constructor: function (config) {
+         *              this.callParent(arguments); // calls Ext.tip.ToolTip's constructor
+         *              //...
+         *          }
+         *      });
+         *
+         * Overrides can also contain statics:
+         *
+         *      Ext.define('My.app.BarMod', {
+         *          override: 'Ext.foo.Bar',
+         *
+         *          statics: {
+         *              method: function (x) {
+         *                  return this.callParent([x * 2]); // call Ext.foo.Bar.method
+         *              }
+         *          }
+         *      });
+         *
+         * @param {String} className The class name to create in string dot-namespaced format, for example:
+         * 'My.very.awesome.Class', 'FeedViewer.plugin.CoolPager'
+         * It is highly recommended to follow this simple convention:
+         *  - The root and the class name are 'CamelCased'
+         *  - Everything else is lower-cased
+         * Pass `null` to create an anonymous class.
+         * @param {Object} data The key - value pairs of properties to apply to this class. Property names can be of any valid
+         * strings, except those in the reserved listed below:
+         *  - `mixins`
+         *  - `statics`
+         *  - `config`
+         *  - `alias`
+         *  - `self`
+         *  - `singleton`
+         *  - `alternateClassName`
+         *  - `override`
+         *
+         * @param {Function} createdFn Optional callback to execute after the class is created, the execution scope of which
+         * (`this`) will be the newly created class itself.
+         * @return {Ext.Base}
+         * @markdown
+         * @member Ext
+         * @method define
+         */
+        define: function (className, body, createdFn) {
+            var override = body.override,
+                cls, extend, name, namespace;
+
+            if (override) {
+                delete body.override;
+                cls = Ext.getClassByName(override);
+                Ext.override(cls, body);
+            } else {
+                if (className) {
+                    namespace = Ext.createNamespace(className, true);
+                    name = className.substring(className.lastIndexOf('.')+1);
+                }
+
+                cls = function ctor () {
+                    this.constructor.apply(this, arguments);
+                }
+
+                if (className) {
+                    cls.displayName = className;
+                }
+                cls.$isClass = true;
+                cls.callParent = Ext.Base.callParent;
+
+                if (typeof body == 'function') {
+                    body = body(cls);
+                }
+
+                extend = body.extend;
+                if (extend) {
+                    delete body.extend;
+                    if (typeof extend == 'string') {
+                        extend = Ext.getClassByName(extend);
+                    }
+                } else {
+                    extend = Base;
+                }
+
+                Ext.extend(cls, extend, body);
+                if (cls.prototype.constructor === cls) {
+                    delete cls.prototype.constructor;
+                }
+
+                // Not extending a class which derives from Base...
+                if (!cls.prototype.$isClass) {
+                    Ext.applyIf(cls.prototype, Base.prototype);
+                }
+                cls.prototype.self = cls;
+
+                if (body.xtype) {
+                    Ext.reg(body.xtype, cls);
+                }
+                cls = body.singleton ? new cls() : cls;
+                if (className) {
+                    namespace[name] = cls;
+                }
+            }
+
+            if (createdFn) {
+                createdFn.call(cls);
+            }
+
+            return cls;
+        },
+
+        /**
+         * Overrides members of the specified `target` with the given values.
+         *
+         * If the `target` is a function, it is assumed to be a constructor and the contents
+         * of `overrides` are applied to its `prototype` using {@link Ext#apply Ext.apply}.
+         *
+         * If the `target` is an instance of a class created using {@link #define},
+         * the `overrides` are applied to only that instance. In this case, methods are
+         * specially processed to allow them to use {@link Ext.Base#callParent}.
+         *
+         *      var panel = new Ext.Panel({ ... });
+         *
+         *      Ext.override(panel, {
+         *          initComponent: function () {
+         *              // extra processing...
+         *
+         *              this.callParent();
+         *          }
+         *      });
+         *
+         * If the `target` is none of these, the `overrides` are applied to the `target`
+         * using {@link Ext#apply Ext.apply}.
+         *
+         * Please refer to {@link Ext#define Ext.define} for further details.
+         *
+         * @param {Object} target The target to override.
+         * @param {Object} overrides The properties to add or replace on `target`.
          * @method override
          */
-        override : function(origclass, overrides){
+        override: function (target, overrides) {
+            var proto, statics;
+
             if (overrides) {
-                var p = origclass.prototype;
+                if (target.$isClass) {
-                Ext.apply(p, overrides);
+                    statics = overrides.statics;
+                    if (statics) {
+                        delete overrides.statics;
+                    }
+
+                    Ext.addMembers(target, target.prototype, overrides, true);
+                    if (statics) {
+                        Ext.addMembers(target, target, statics);
+                    }
+                } else if (typeof target == 'function') {
+                    proto = target.prototype;
+                    Ext.apply(proto, overrides);
                     if(Ext.isIE && overrides.hasOwnProperty('toString')){
-                    p.toString = overrides.toString;
+                        proto.toString = overrides.toString;
+                    }
+                } 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') {
+                                    //<debug>
+                                    if (owner.$className) {
+                                        value.displayName = owner.$className + '#' + name;
+                                    }
+                                    //</debug>
+
+                                    value.$name = name;
+                                    value.$owner = owner;
+                                    value.$previous = target.hasOwnProperty(name)
+                                        ? target[name] // already hooked, so call previous hook
+                                        : callOverrideParent; // calls by name on prototype
+                                }
+
+                                target[name] = value;
+                            }
+                        }
+                    } else {
+                        Ext.apply(target, overrides);
+
+                        if (!target.constructor.$isClass) {
+                            target.constructor.prototype.callParent = Base.prototype.callParent;
+                            target.constructor.callParent = Base.callParent;
+                        }
+                    }
                 }
             }
         },
@@ -573,6 +995,7 @@ function(el){
         /**
          * Returns the current document body as an {@link Ext.Element}.
          * @return Ext.Element The document body
+         * @method
          */
         getHead : function() {
             var head;
@@ -586,15 +1009,13 @@ function(el){
             };
         }(),
 
-        /**
-         * Removes a DOM node from the document.
-         */
         /**
          * <p>Removes this element from the document, removes all DOM event listeners, and deletes the cache reference.
          * All DOM event listeners are removed from this element. If {@link Ext#enableNestedListenerRemoval} is
          * <code>true</code>, then DOM event listeners are also removed from all child nodes. The body node
          * will be ignored if passed in.</p>
          * @param {HTMLElement} node The node to remove
+         * @method
          */
         removeNode : isIE && !isIE8 ? function(){
             var d;
@@ -781,6 +1202,29 @@ function(el){
          * @type Boolean
          */
         isIE9 : isIE9,
+
+        /**
+         * True if the detected browser is Internet Explorer 10.x
+         * @type Boolean
+         */
+        isIE10 : isIE10,
+
+        /**
+         * True if the detected browser is Internet Explorer 9.x or lower
+         * @type Boolean
+         */
+        isIE9m : isIE9m,
+
+        /**
+         * True if the detected browser is Internet Explorer 10.x or higher
+         * @type Boolean
+         */
+        isIE10p : isIE && !(isIE6 || isIE7 || isIE8 || isIE9),
+
+        // IE10 quirks behaves like Gecko/WebKit quirks, so don't include it here
+        // Used internally
+        isIEQuirks: isIE && (!isStrict && (isIE6 || isIE7 || isIE8 || isIE9)),
+
         /**
          * True if the detected browser uses the Gecko layout engine (e.g. Mozilla, Firefox).
          * @type Boolean
@@ -1297,14 +1741,14 @@ Ext.TaskMgr = new Ext.util.TaskRunner();(function(){
         },
 
         getViewportHeight: function(){
-	        return Ext.isIE ?
+	        return Ext.isIE9m ?
 	        	   (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;
+	        	   Ext.isIE9m ? doc.documentElement.clientWidth : self.innerWidth;
         },
 
         getY : function(el) {
@@ -1719,7 +2163,7 @@ Ext.TaskMgr = new Ext.util.TaskRunner();(function(){
         _load : function(e) {
             loadComplete = true;
 
-            if (Ext.isIE && e !== true) {
+            if (Ext.isIE9m && e !== true) {
                 // IE8 complains that _load is null or not an object
                 // so lets remove self via arguments.callee
                 doRemove(win, "load", arguments.callee);
@@ -1769,8 +2213,7 @@ Ext.TaskMgr = new Ext.util.TaskRunner();(function(){
 * http://developer.yahoo.net/yui/license.txt
 */
 Ext.lib.Ajax = function() {
-    var activeX = ['Msxml2.XMLHTTP.6.0',
+    var activeX = ['Msxml2.XMLHTTP.3.0',
-                   'Msxml2.XMLHTTP.3.0',
                    'Msxml2.XMLHTTP'],
         CONTENTTYPE = 'Content-Type';
 
@@ -2893,7 +3336,7 @@ Ext.lib.Ajax = function() {
         }
     });
 })();
-	if (Ext.isIE) {
+	if (Ext.isIE9m) {
         function fnCleanUp() {
             var p = Function.prototype;
             delete p.createSequence;