Upgrade to ExtJS 3.3.1 - Released 11/30/2010
[extjs.git] / src / widgets / tree / TreeSorter.js
index 632e8c8..aeabcbe 100644 (file)
 /*!
 /*!
- * Ext JS Library 3.0.0
- * Copyright(c) 2006-2009 Ext JS, LLC
- * licensing@extjs.com
- * http://www.extjs.com/license
+ * Ext JS Library 3.3.1
+ * Copyright(c) 2006-2010 Sencha Inc.
+ * licensing@sencha.com
+ * http://www.sencha.com/license
  */
  */
-/**\r
- * @class Ext.tree.TreeSorter\r
- * Provides sorting of nodes in a {@link Ext.tree.TreePanel}.  The TreeSorter automatically monitors events on the \r
- * associated TreePanel that might affect the tree's sort order (beforechildrenrendered, append, insert and textchange).\r
- * Example usage:<br />\r
- * <pre><code>\r
-new Ext.tree.TreeSorter(myTree, {\r
-    folderSort: true,\r
-    dir: "desc",\r
-    sortType: function(node) {\r
-        // sort by a custom, typed attribute:\r
-        return parseInt(node.id, 10);\r
-    }\r
-});\r
-</code></pre>\r
- * @constructor\r
- * @param {TreePanel} tree\r
- * @param {Object} config\r
- */\r
-Ext.tree.TreeSorter = function(tree, config){\r
-    /**\r
-     * @cfg {Boolean} folderSort True to sort leaf nodes under non-leaf nodes (defaults to false)\r
-     */\r
-    /** \r
-     * @cfg {String} property The named attribute on the node to sort by (defaults to "text").  Note that this \r
-     * property is only used if no {@link #sortType} function is specified, otherwise it is ignored.\r
-     */\r
-    /** \r
-     * @cfg {String} dir The direction to sort ("asc" or "desc," case-insensitive, defaults to "asc")\r
-     */\r
-    /** \r
-     * @cfg {String} leafAttr The attribute used to determine leaf nodes when {@link #folderSort} = true (defaults to "leaf")\r
-     */\r
-    /** \r
-     * @cfg {Boolean} caseSensitive true for case-sensitive sort (defaults to false)\r
-     */\r
-    /** \r
-     * @cfg {Function} sortType A custom "casting" function used to convert node values before sorting.  The function\r
-     * will be called with a single parameter (the {@link Ext.tree.TreeNode} being evaluated) and is expected to return\r
-     * the node's sort value cast to the specific data type required for sorting.  This could be used, for example, when\r
-     * a node's text (or other attribute) should be sorted as a date or numeric value.  See the class description for \r
-     * example usage.  Note that if a sortType is specified, any {@link #property} config will be ignored.\r
-     */\r
-    \r
-    Ext.apply(this, config);\r
-    tree.on("beforechildrenrendered", this.doSort, this);\r
-    tree.on("append", this.updateSort, this);\r
-    tree.on("insert", this.updateSort, this);\r
-    tree.on("textchange", this.updateSortParent, this);\r
-    \r
-    var dsc = this.dir && this.dir.toLowerCase() == "desc";\r
-    var p = this.property || "text";\r
-    var sortType = this.sortType;\r
-    var fs = this.folderSort;\r
-    var cs = this.caseSensitive === true;\r
-    var leafAttr = this.leafAttr || 'leaf';\r
-\r
-    this.sortFn = function(n1, n2){\r
-        if(fs){\r
-            if(n1.attributes[leafAttr] && !n2.attributes[leafAttr]){\r
-                return 1;\r
-            }\r
-            if(!n1.attributes[leafAttr] && n2.attributes[leafAttr]){\r
-                return -1;\r
-            }\r
-        }\r
-       var v1 = sortType ? sortType(n1) : (cs ? n1.attributes[p] : n1.attributes[p].toUpperCase());\r
-       var v2 = sortType ? sortType(n2) : (cs ? n2.attributes[p] : n2.attributes[p].toUpperCase());\r
-       if(v1 < v2){\r
-                       return dsc ? +1 : -1;\r
-               }else if(v1 > v2){\r
-                       return dsc ? -1 : +1;\r
-        }else{\r
-               return 0;\r
-        }\r
-    };\r
-};\r
-\r
-Ext.tree.TreeSorter.prototype = {\r
-    doSort : function(node){\r
-        node.sort(this.sortFn);\r
-    },\r
-    \r
-    compareNodes : function(n1, n2){\r
-        return (n1.text.toUpperCase() > n2.text.toUpperCase() ? 1 : -1);\r
-    },\r
-    \r
-    updateSort : function(tree, node){\r
-        if(node.childrenRendered){\r
-            this.doSort.defer(1, this, [node]);\r
-        }\r
-    },\r
-    \r
-    updateSortParent : function(node){\r
-               var p = node.parentNode;\r
-               if(p && p.childrenRendered){\r
-            this.doSort.defer(1, this, [p]);\r
-        }\r
-    }\r
-};
\ No newline at end of file
+/**
+ * @class Ext.tree.TreeSorter
+ * Provides sorting of nodes in a {@link Ext.tree.TreePanel}.  The TreeSorter automatically monitors events on the
+ * associated TreePanel that might affect the tree's sort order (beforechildrenrendered, append, insert and textchange).
+ * Example usage:<br />
+ * <pre><code>
+new Ext.tree.TreeSorter(myTree, {
+    folderSort: true,
+    dir: "desc",
+    sortType: function(node) {
+        // sort by a custom, typed attribute:
+        return parseInt(node.id, 10);
+    }
+});
+</code></pre>
+ * @constructor
+ * @param {TreePanel} tree
+ * @param {Object} config
+ */
+Ext.tree.TreeSorter = Ext.extend(Object, {
+    
+    constructor: function(tree, config){
+        /**
+     * @cfg {Boolean} folderSort True to sort leaf nodes under non-leaf nodes (defaults to false)
+     */
+    /**
+     * @cfg {String} property The named attribute on the node to sort by (defaults to "text").  Note that this
+     * property is only used if no {@link #sortType} function is specified, otherwise it is ignored.
+     */
+    /**
+     * @cfg {String} dir The direction to sort ("asc" or "desc," case-insensitive, defaults to "asc")
+     */
+    /**
+     * @cfg {String} leafAttr The attribute used to determine leaf nodes when {@link #folderSort} = true (defaults to "leaf")
+     */
+    /**
+     * @cfg {Boolean} caseSensitive true for case-sensitive sort (defaults to false)
+     */
+    /**
+     * @cfg {Function} sortType A custom "casting" function used to convert node values before sorting.  The function
+     * will be called with a single parameter (the {@link Ext.tree.TreeNode} being evaluated) and is expected to return
+     * the node's sort value cast to the specific data type required for sorting.  This could be used, for example, when
+     * a node's text (or other attribute) should be sorted as a date or numeric value.  See the class description for
+     * example usage.  Note that if a sortType is specified, any {@link #property} config will be ignored.
+     */
+
+    Ext.apply(this, config);
+    tree.on({
+        scope: this,
+        beforechildrenrendered: this.doSort,
+        append: this.updateSort,
+        insert: this.updateSort,
+        textchange: this.updateSortParent
+    });
+
+    var desc = this.dir && this.dir.toLowerCase() == 'desc',
+        prop = this.property || 'text';
+        sortType = this.sortType;
+        folderSort = this.folderSort;
+        caseSensitive = this.caseSensitive === true;
+        leafAttr = this.leafAttr || 'leaf';
+
+    if(Ext.isString(sortType)){
+        sortType = Ext.data.SortTypes[sortType];
+    }
+    this.sortFn = function(n1, n2){
+        var attr1 = n1.attributes,
+            attr2 = n2.attributes;
+            
+        if(folderSort){
+            if(attr1[leafAttr] && !attr2[leafAttr]){
+                return 1;
+            }
+            if(!attr1[leafAttr] && attr2[leafAttr]){
+                return -1;
+            }
+        }
+        var prop1 = attr1[prop],
+            prop2 = attr2[prop],
+            v1 = sortType ? sortType(prop1) : (caseSensitive ? prop1 : prop1.toUpperCase());
+            v2 = sortType ? sortType(prop2) : (caseSensitive ? prop2 : prop2.toUpperCase());
+            
+        if(v1 < v2){
+            return desc ? 1 : -1;
+        }else if(v1 > v2){
+            return desc ? -1 : 1;
+        }
+        return 0;
+    };
+    },
+    
+    doSort : function(node){
+        node.sort(this.sortFn);
+    },
+
+    updateSort : function(tree, node){
+        if(node.childrenRendered){
+            this.doSort.defer(1, this, [node]);
+        }
+    },
+
+    updateSortParent : function(node){
+        var p = node.parentNode;
+        if(p && p.childrenRendered){
+            this.doSort.defer(1, this, [p]);
+        }
+    }    
+});
\ No newline at end of file