Changeset 12481

Timestamp:

02/17/08 04:13:48 (11 months ago)

Author:

bill

Message:

Specify root item of tree using query parameter (like in v1.0) rather than "root" parameter. But query returning multiple items (rather than a single item) is deprecated; plan to remove in 2.0. Fixes #5879. !strict

Location:

dijit/trunk

Files:

• tests/test_Tree.html (modified) (2 diffs)
• tests/tree/test_Tree_v1.html (modified) (1 diff)
• Tree.js (modified) (4 diffs)
• _tree/ForestStoreDecorator.js (modified) (3 diffs)

dijit/trunk/tests/test_Tree.html

@@ -37 +37 @@
         <p>Clicking a folder node will open/close it (openOnclick==true), and clicking a leaf node will popup an alert.</p>
         <div dojoType="dijit.Tree" id="mytree"
-                store="continentStoreDecorated" root="continentRoot" labelAttr="name" childrenAttr="children"
+                store="continentStoreDecorated" labelAttr="name" childrenAttr="children"
                 openOnClick="true">
                 <script type="dojo/method" event="onClick" args="item">
@@ -82 +82 @@
 
         <div dojoType="dijit.Tree" id="tree2"
-                store="continentStoreDecorated" root="continentRoot" labelAttr="name" childrenAttr="children"
+                store="continentStoreDecorated" labelAttr="name" childrenAttr="children"
                 showRoot="false" openOnClick="true">
 

dijit/trunk/tests/tree/test_Tree_v1.html

@@ -6 +6 @@
 
         <style type="text/css">
-                @import "../../../../dojo/resources/dojo.css";
-                @import "css/dijitTests.css";
+                @import "../../../dojo/resources/dojo.css";
+                @import "../css/dijitTests.css";
         </style>
 
-
-        <script type="text/javascript" src="../../../../dojo/dojo.js"
+        <script type="text/javascript" src="../../../dojo/dojo.js"
                 djConfig="parseOnLoad: true, isDebug: true"></script>
-        <script type="text/javascript" src="_testCommon.js"></script>
+        <script type="text/javascript" src="../_testCommon.js"></script>
 
         <script language="JavaScript" type="text/javascript">

dijit/trunk/Tree.js

@@ -215 +215 @@
                 // On initial tree show, put focus on either the root node of the tree,
                 // or the first child, if the root node is hidden
-                // TODO: move to Tree.postCreate?  (but can't execute until root node and child nodes finish loading)
                 if(!this.parent){
                         var fc = this.tree.showRoot ? this : this.getChildren()[0],
@@ -270 +269 @@
         store: null,
 
-        // root: String
-        //      id of item in store corresponding to root of tree
-        root: "",
-
-        // query: String
-        //      Deprecated.  Use dijit._tree.ForestStoreDecorator directly instead.
-        //      Specifies a set of "top level" items for the tree, rather than just a single item.
-        //      If a label is also specified, the tree is given a fake root node (not corresponding to an item in
-        //      the data store), whose children are the items that match this query.
-        // 
+        // query: anything
+        //      Specifies datastore query to return the root item for the tree.
+        //
+        //      Deprecated functionality: if the query returns multiple items, the tree is given
+        //      a fake root node (not corresponding to any item in the data store), 
+        //      whose children are the items that match this query.
+        //
+        //      The root node is shown or hidden based on whether a label is specified.
+        //
+        //      Having a query return multiple items is deprecated.
+        //      If your store doesn't have a root item, wrap the store with
+        //      dijit._tree.ForestStoreDecorator, and specify store=myDecoratedStore query="$root$".
+        //
         // example:
         //              {type:'continent'}
@@ -337 +339 @@
 
                 this._itemNodeMap={};
-
-                if(!this.root){
-                        // 1.0 compatible behavior.
-                        // Provide (possibly hidden) fake root node not corresponding to any data store item,
-                        // which fathers all the items returned by fetch({query: this.query})
-                        dojo.deprecated("Tree: from version 2.0, must specify root item id (using root parameter) rather than query/label parameters when constructing a dijit.Tree; use dijit._tree.ForestStoreDecorator if your data store has no root item.");
-                        this._v10Compat = true;
-                        this.underlyingStore = this.store;
-                        this.root = "$root$";
-                        this.store = new dijit._tree.ForestStoreDecorator({
-                                id: this.id + "_ForestStoreDecorator",
-                                store: this.underlyingStore,
-                                query: this.query,
-                                childrenAttr: this.childrenAttr[0],
-                                rootId: this.root,
-                                rootLabel: this.label||"ROOT"
-                        });
-
-                        // For backwards compatibility, the visibility of the root node is controlled by
-                        // whether or not the user has specified a label
-                        this.showRoot = Boolean(this.label);
-                }
 
                 if(!this.store.getFeatures()['dojo.data.api.Identity']){
@@ -397 +377 @@
 
                 // load root node (possibly hidden) and it's children
-                var _this = this;
-                this.store.fetchItemByIdentity({
-                        identity: this.root,
-                        onItem: function(item){
-                                _this.rootItem = item;
-
-                                var rn = _this.rootNode = new dijit._TreeNode({
+                this.store.fetch({
+                        query: this.query,
+                        onComplete: dojo.hitch(this, function(items){
+                                if(items.length > 1){
+                                        // 1.0 compatible behavior.
+                                        // Provide (possibly hidden) fake root node not corresponding to any data store item,
+                                        // which fathers all the items returned by fetch({query: this.query})
+                                        dojo.deprecated("Tree: from version 2.0, query must return a single root item; use dijit._tree.ForestStoreDecorator if your data store has no root item.");
+                                        this._v10Compat = true;
+                                        this.underlyingStore = this.store;
+                                        this.root = "$root$";
+                                        this.store = new dijit._tree.ForestStoreDecorator({
+                                                id: this.id + "_ForestStoreDecorator",
+                                                store: this.underlyingStore,
+                                                childrenAttr: this.childrenAttr[0],
+                                                rootId: this.root,
+                                                rootLabel: this.label||"ROOT",
+                                                rootChildren: items
+                                        });
+                                        var item = this.store.root;
+                
+                                        // For backwards compatibility, the visibility of the root node is controlled by
+                                        // whether or not the user has specified a label
+                                        this.showRoot = Boolean(this.label);
+                                }else{
+                                        item = items[0];
+                                }
+
+                                var rn = this.rootNode = new dijit._TreeNode({
                                         item: item,
-                                        tree: _this,
+                                        tree: this,
                                         isExpandable: true,
-                                        label: _this.label || _this.getLabel(item)
+                                        label: this.label || this.getLabel(item)
                                 });
-                                if(!_this.showRoot){
+                                if(!this.showRoot){
                                         rn.rowNode.style.display="none";
                                 }
-                                _this.domNode.appendChild(rn.domNode);
-                                _this._itemNodeMap[_this.root] = rn;
+                                this.domNode.appendChild(rn.domNode);
+                                this._itemNodeMap[this.store.getIdentity(item)] = rn;
 
                                 rn._updateLayout();             // sets "dijitTreeIsRoot" CSS classname
 
                                 // load top level children
-                                _this._expandNode(rn);
-                        }
+                                this._expandNode(rn);
+                        })
                 });
 

dijit/trunk/_tree/ForestStoreDecorator.js

@@ -26 +26 @@
         // rootId: String
         //      ID of root item
-        rootId: "",
+        rootId: "$root$",
 
         // rootLabel: String
         //      Label of root item
-        rootLabel: "",
+        rootLabel: "ROOT",
 
         // childrenAttr: String
@@ -57 +57 @@
                         id: params.rootId,
                         label: params.rootLabel,
-                        children: []
+                        children: params.rootChildren || []
                 };
 
@@ -234 +234 @@
 
         fetch: function(/* Object */ args){
-                return this.store.fetch(args);
+                if(!args.query){
+                        // No query means to get the (fake) root item
+                        return this.fetchItemByIdentity({
+                                identity: this.rootId,
+                                onItem: function(item){ args.onComplete([item]); },
+                                onError: args.onError
+                        });
+                }else{
+                        // Not sure if another query should search the items in the underlying store
+                        // or just return empty list; I think this code path will never execute anyway.
+                        return this.store.fetch(args);
+                }
         },