dojo-rails 0.9.0

data/vendor/assets/javascripts/dojox/grid/TreeGrid.js.uncompressed.js

@@ -0,0 +1,969 @@
+define("dojox/grid/TreeGrid", [
+	"dojo/_base/kernel",
+	"../main",
+	"dojo/_base/declare",
+	"dojo/_base/array",
+	"dojo/_base/lang",
+	"dojo/_base/event",
+	"dojo/dom-attr",
+	"dojo/dom-class",
+	"dojo/query",
+	"dojo/keys",
+	"dijit/tree/ForestStoreModel",
+	"./DataGrid",
+	"./_Layout",
+	"./_FocusManager",
+	"./_RowManager",
+	"./_EditManager",
+	"./TreeSelection",
+	"./cells/tree",
+	"./_TreeView"
+], function(dojo, dojox, declare, array, lang, event, domAttr, domClass, query, keys, ForestStoreModel, 
+	DataGrid, _Layout, _FocusManager, _RowManager, _EditManager, TreeSelection, TreeCell){
+		
+dojo.experimental("dojox.grid.TreeGrid");
+
+var _TreeAggregator = declare("dojox.grid._TreeAggregator", null, {
+	cells: [],
+	grid: null,
+	childFields: [],
+	
+	constructor: function(kwArgs){
+		this.cells = kwArgs.cells || [];
+		this.childFields = kwArgs.childFields || [];
+		this.grid = kwArgs.grid;
+		this.store = this.grid.store;
+	},
+	_cacheValue: function(cache, id, value){
+		cache[id] = value;
+		return value;
+	},
+	clearSubtotalCache: function(){
+		// summary:
+		//		Clears the subtotal cache so that we are forced to recalc it
+		//		(or reread it) again.  This is needed, for example, when
+		//		column order is changed.
+		if(this.store){
+			delete this.store._cachedAggregates;
+		}
+	},
+	
+	cnt: function(cell, level, item){
+		// summary:
+		//		calculates the count of the children of item at the given level
+		var total = 0;
+		var store = this.store;
+		var childFields = this.childFields;
+		if(childFields[level]){
+			var children = store.getValues(item, childFields[level]);
+			if (cell.index <= level + 1){
+				total = children.length;
+			}else{
+				array.forEach(children, function(c){
+					total += this.getForCell(cell, level + 1, c, "cnt");
+				}, this);
+			}
+		}else{
+			total = 1;
+		}
+		return total;
+	},
+	sum: function(cell, level, item){
+		// summary:
+		//		calculates the sum of the children of item at the given level
+		var total = 0;
+		var store = this.store;
+		var childFields = this.childFields;
+		if(childFields[level]){
+			array.forEach(store.getValues(item, childFields[level]), function(c){
+				total += this.getForCell(cell, level + 1, c, "sum");
+			}, this);
+		}else{
+			total += store.getValue(item, cell.field);
+		}
+		return total;
+	},
+	value: function(cell, level, item){
+		// summary:
+		//		Empty function so that we can set "aggregate='value'" to
+		//		force loading from the data - and bypass calculating
+	},
+	getForCell: function(cell, level, item, type){
+		// summary:
+		//		Gets the value of the given cell at the given level and type.
+		//		type can be one of "sum", "cnt", or "value".  If itemAggregates
+		//		is set and can be used, it is used instead.  Values are also
+		//		cached to prevent calculating them too often.
+		var store = this.store;
+		if(!store || !item || !store.isItem(item)){ return ""; }
+		var storeCache = store._cachedAggregates = store._cachedAggregates || {};
+		var id = store.getIdentity(item);
+		var itemCache = storeCache[id] = storeCache[id] || [];
+		if(!cell.getOpenState){
+			cell = this.grid.getCell(cell.layoutIndex + level + 1);
+		}
+		var idx = cell.index;
+		var idxCache = itemCache[idx] = itemCache[idx] || {};
+		type = (type || (cell.parentCell ? cell.parentCell.aggregate : "sum"))||"sum";
+		var attr = cell.field;
+		if(attr == store.getLabelAttributes()[0]){
+			// If our attribute is one of the label attributes, we should
+			// use cnt instead (since it makes no sense to do a sum of labels)
+			type = "cnt";
+		}
+		var typeCache = idxCache[type] = idxCache[type] || [];
+
+		// See if we have it in our cache immediately for easy returning
+		if(typeCache[level] != undefined){
+			return typeCache[level];
+		}
+
+		// See if they have specified a valid field
+		var field = ((cell.parentCell && cell.parentCell.itemAggregates) ?
+							cell.parentCell.itemAggregates[cell.idxInParent] : "")||"";
+		if(field && store.hasAttribute(item, field)){
+			return this._cacheValue(typeCache, level, store.getValue(item, field));
+		}else if(field){
+			return this._cacheValue(typeCache, level, 0);
+		}
+		
+		// Calculate it
+		return this._cacheValue(typeCache, level, this[type](cell, level, item));
+	}
+});
+
+var _TreeLayout = declare("dojox.grid._TreeLayout", _Layout, {
+	// Whether or not we are collapsable - this is calculated when we
+	// set our structure.
+	_isCollapsable: false,
+	
+	_getInternalStructure: function(inStructure){
+		//	Create a "Tree View" with 1 row containing references for
+		//		each column (recursively)
+		var g = this.grid;
+		
+		var s = inStructure;
+		var cells = s[0].cells[0];
+		var tree = {
+			type: "dojox.grid._TreeView",
+			cells: [[]]
+		};
+		var cFields = [];
+		var maxLevels = 0;
+		var getTreeCells = function(parentCell, level){
+			var children = parentCell.children;
+			var cloneTreeCell = function(originalCell, idx){
+				var k, n = {};
+				for(k in originalCell){
+					n[k] = originalCell[k];
+				}
+				n = lang.mixin(n, {
+					level: level,
+					idxInParent: level > 0 ? idx : -1,
+					parentCell: level > 0 ? parentCell : null
+				});
+				return n;
+			};
+			var ret = [];
+			array.forEach(children, function(c, idx){
+				if("children" in c){
+					cFields.push(c.field);
+					var last = ret[ret.length - 1];
+					last.isCollapsable = true;
+					c.level = level;
+					ret = ret.concat(getTreeCells(c, level + 1));
+				}else{
+					ret.push(cloneTreeCell(c, idx));
+				}
+			});
+			maxLevels = Math.max(maxLevels, level);
+			return ret;
+		};
+		var tCell = {children: cells, itemAggregates: []};
+		tree.cells[0] = getTreeCells(tCell, 0);
+		g.aggregator = new _TreeAggregator({cells: tree.cells[0],
+														grid: g,
+														childFields: cFields});
+		if(g.scroller && g.defaultOpen){
+			g.scroller.defaultRowHeight = g.scroller._origDefaultRowHeight * (2 * maxLevels + 1);
+		}
+		return [ tree ];
+	},
+
+	setStructure: function(inStructure){
+		// Mangle the structure a bit and make it work as desired
+		var s = inStructure;
+		var g = this.grid;
+		// Only supporting single-view, single row or else we
+		// are not collapsable
+		if(g && g.treeModel && !array.every(s, function(i){
+			return ("cells" in i);
+		})){
+			s = arguments[0] = [{cells:[s]}];
+		}
+		if(s.length == 1 && s[0].cells.length == 1){
+			if(g && g.treeModel){
+				s[0].type = "dojox.grid._TreeView";
+				this._isCollapsable = true;
+				s[0].cells[0][(this.grid.treeModel?this.grid.expandoCell:0)].isCollapsable = true;
+			}else{
+				var childCells = array.filter(s[0].cells[0], function(c){
+					return ("children" in c);
+				});
+				if(childCells.length === 1){
+					this._isCollapsable = true;
+				}
+			}
+		}
+		if(this._isCollapsable && (!g || !g.treeModel)){
+			arguments[0] = this._getInternalStructure(s);
+		}
+		this.inherited(arguments);
+	},
+
+	addCellDef: function(inRowIndex, inCellIndex, inDef){
+		var obj = this.inherited(arguments);
+		return lang.mixin(obj, TreeCell);
+	}
+});
+
+var TreePath = declare("dojox.grid.TreePath", null, {
+	level: 0,
+	_str: "",
+	_arr: null,
+	grid: null,
+	store: null,
+	cell: null,
+	item: null,
+
+	constructor: function(/*String|Integer[]|Integer|dojox.grid.TreePath*/ path, /*dojox.grid.TreeGrid*/ grid){
+		if(lang.isString(path)){
+			this._str = path;
+			this._arr = array.map(path.split('/'), function(item){ return parseInt(item, 10); });
+		}else if(lang.isArray(path)){
+			this._str = path.join('/');
+			this._arr = path.slice(0);
+		}else if(typeof path == "number"){
+			this._str = String(path);
+			this._arr = [path];
+		}else{
+			this._str = path._str;
+			this._arr = path._arr.slice(0);
+		}
+		this.level = this._arr.length-1;
+		this.grid = grid;
+		this.store = this.grid.store;
+		if(grid.treeModel){
+			this.cell = grid.layout.cells[grid.expandoCell];
+		}else{
+			this.cell = grid.layout.cells[this.level];
+		}
+	},
+	item: function(){
+		// summary:
+		//	gets the dojo.data item associated with this path
+		if(!this._item){
+			this._item = this.grid.getItem(this._arr);
+		}
+		return this._item;
+	},
+	compare: function(path /*dojox.grid.TreePath|String|Array*/){
+		// summary:
+		//	compares two paths
+		if(lang.isString(path) || lang.isArray(path)){
+			if(this._str == path){ return 0; }
+			if(path.join && this._str == path.join('/')){ return 0; }
+			path = new TreePath(path, this.grid);
+		}else if(path instanceof TreePath){
+			if(this._str == path._str){ return 0; }
+		}
+		for(var i=0, l=(this._arr.length < path._arr.length ? this._arr.length : path._arr.length); i<l; i++){
+			if(this._arr[i]<path._arr[i]){ return -1; }
+			if(this._arr[i]>path._arr[i]){ return 1; }
+		}
+		if(this._arr.length<path._arr.length){ return -1; }
+		if(this._arr.length>path._arr.length){ return 1; }
+		return 0;
+	},
+	isOpen: function(){
+		// summary:
+		//	Returns the open state of this cell.
+		return this.cell.openStates && this.cell.getOpenState(this.item());
+	},
+	previous: function(){
+		// summary:
+		//	Returns the path that is before this path in the
+		//	grid. If no path is found, returns null.
+		var new_path = this._arr.slice(0);
+
+		if(this._str == "0"){
+			return null;
+		}
+
+		var last = new_path.length-1;
+
+		if(new_path[last] === 0){
+			new_path.pop();
+			return new TreePath(new_path, this.grid);
+		}
+
+		new_path[last]--;
+		var path = new TreePath(new_path, this.grid);
+		return path.lastChild(true);
+	},
+	next: function(){
+		// summary:
+		//	Returns the next path in the grid.  If no path
+		//	is found, returns null.
+		var new_path = this._arr.slice(0);
+
+		if(this.isOpen()){
+			new_path.push(0);
+		}else{
+			new_path[new_path.length-1]++;
+			for(var i=this.level; i>=0; i--){
+				var item = this.grid.getItem(new_path.slice(0, i+1));
+				if(i>0){
+					if(!item){
+						new_path.pop();
+						new_path[i-1]++;
+					}
+				}else{
+					if(!item){
+						return null;
+					}
+				}
+			}
+		}
+
+		return new TreePath(new_path, this.grid);
+	},
+	children: function(alwaysReturn){
+		// summary:
+		//	Returns the child data items of this row.  If this
+		//	row isn't open and alwaysReturn is falsey, returns null.
+		if(!this.isOpen()&&!alwaysReturn){
+			return null;
+		}
+		var items = [];
+		var model = this.grid.treeModel;
+		if(model){
+			var item = this.item();
+			var store = model.store;
+			if(!model.mayHaveChildren(item)){
+				return null;
+			}
+			array.forEach(model.childrenAttrs, function(attr){
+				items = items.concat(store.getValues(item, attr));
+			});
+		}else{
+			items = this.store.getValues(this.item(), this.grid.layout.cells[this.cell.level+1].parentCell.field);
+			if(items.length>1&&this.grid.sortChildItems){
+				var sortProps = this.grid.getSortProps();
+				if(sortProps&&sortProps.length){
+					var attr = sortProps[0].attribute,
+						grid = this.grid;
+					if(attr&&items[0][attr]){
+						var desc = !!sortProps[0].descending;
+						items = items.slice(0); // don't touch the array in the store, make a copy
+						items.sort(function(a, b){
+							return grid._childItemSorter(a, b, attr, desc);
+						});
+					}
+				}
+			}
+		}
+		return items;
+	},
+	childPaths: function(){
+		var childItems = this.children();
+		if(!childItems){
+			return [];
+		}
+		return array.map(childItems, function(item, index){
+			return new TreePath(this._str + '/' + index, this.grid);
+		}, this);
+	},
+	parent: function(){
+		// summary:
+		//	Returns the parent path of this path.  If this is a
+		//	top-level row, returns null.
+		if(this.level === 0){
+			return null;
+		}
+		return new TreePath(this._arr.slice(0, this.level), this.grid);
+	},
+	lastChild: function(/*Boolean?*/ traverse){
+		// summary:
+		//	Returns the last child row below this path.  If traverse
+		//	is true, will traverse down to find the last child row
+		//	of this branch.  If there are no children, returns itself.
+		var children = this.children();
+		if(!children || !children.length){
+			return this;
+		}
+		var path = new TreePath(this._str + "/" + String(children.length-1), this.grid);
+		if(!traverse){
+			return path;
+		}
+		return path.lastChild(true);
+	},
+	toString: function(){
+		return this._str;
+	}
+});
+
+var _TreeFocusManager = declare("dojox.grid._TreeFocusManager", _FocusManager, {
+	setFocusCell: function(inCell, inRowIndex){
+		if(inCell && inCell.getNode(inRowIndex)){
+			this.inherited(arguments);
+		}
+	},
+	isLastFocusCell: function(){
+		if(this.cell && this.cell.index == this.grid.layout.cellCount-1){
+			var path = new TreePath(this.grid.rowCount-1, this.grid);
+			path = path.lastChild(true);
+			return this.rowIndex == path._str;
+		}
+		return false;
+	},
+	next: function(){
+		// summary:
+		//	focus next grid cell
+		if(this.cell){
+			var row=this.rowIndex, col=this.cell.index+1, cc=this.grid.layout.cellCount-1;
+			var path = new TreePath(this.rowIndex, this.grid);
+			if(col > cc){
+				var new_path = path.next();
+				if(!new_path){
+					col--;
+				}else{
+					col = 0;
+					path = new_path;
+				}
+			}
+			if(this.grid.edit.isEditing()){ //when editing, only navigate to editable cells
+				var nextCell = this.grid.getCell(col);
+				if (!this.isLastFocusCell() && !nextCell.editable){
+					this._focusifyCellNode(false);
+					this.cell=nextCell;
+					this.rowIndex=path._str;
+					this.next();
+					return;
+				}
+			}
+			this.setFocusIndex(path._str, col);
+		}
+	},
+	previous: function(){
+		// summary:
+		//	focus previous grid cell
+		if(this.cell){
+			var row=(this.rowIndex || 0), col=(this.cell.index || 0) - 1;
+			var path = new TreePath(row, this.grid);
+			if(col < 0){
+				var new_path = path.previous();
+				if(!new_path){
+					col = 0;
+				}else{
+					col = this.grid.layout.cellCount-1;
+					path = new_path;
+				}
+			}
+			if(this.grid.edit.isEditing()){ //when editing, only navigate to editable cells
+				var prevCell = this.grid.getCell(col);
+				if (!this.isFirstFocusCell() && !prevCell.editable){
+					this._focusifyCellNode(false);
+					this.cell=prevCell;
+					this.rowIndex=path._str;
+					this.previous();
+					return;
+				}
+			}
+			this.setFocusIndex(path._str, col);
+		}
+	},
+	move: function(inRowDelta, inColDelta){
+		if(this.isNavHeader()){
+			this.inherited(arguments);
+			return;
+		}
+		if(!this.cell){ return; }
+		// Handle grid proper.
+		var sc = this.grid.scroller,
+			r = this.rowIndex,
+			rc = this.grid.rowCount-1,
+			path = new TreePath(this.rowIndex, this.grid);
+		if(inRowDelta){
+			var row;
+			if(inRowDelta>0){
+				path = path.next();
+				row = path._arr[0];
+				if(row > sc.getLastPageRow(sc.page)){
+					//need to load additional data, let scroller do that
+					this.grid.setScrollTop(this.grid.scrollTop+sc.findScrollTop(row)-sc.findScrollTop(r));
+				}
+			}else if(inRowDelta<0){
+				path = path.previous();
+				row = path._arr[0];
+				if(row <= sc.getPageRow(sc.page)){
+					//need to load additional data, let scroller do that
+					this.grid.setScrollTop(this.grid.scrollTop-sc.findScrollTop(r)-sc.findScrollTop(row));
+				}
+			}
+		}
+		var cc = this.grid.layout.cellCount-1,
+		i = this.cell.index,
+		col = Math.min(cc, Math.max(0, i+inColDelta));
+		var cell = this.grid.getCell(col);
+		var colDir = inColDelta < 0 ? -1 : 1;
+		while(col>=0 && col < cc && cell && cell.hidden === true){
+			// skip hidden cells
+			col += colDir;
+			cell = this.grid.getCell(col);
+		}
+		if (!cell || cell.hidden === true){
+			// don't change col if would move to hidden
+			col = i;
+		}
+		if(inRowDelta){
+			this.grid.updateRow(r);
+		}
+		this.setFocusIndex(path._str, col);
+	}
+});
+
+var TreeGrid = declare("dojox.grid.TreeGrid", DataGrid, {
+	// summary:
+	//		A grid that supports nesting rows - it provides an expando function
+	//		similar to dijit.Tree.  It also provides mechanisms for aggregating
+	//		the values of subrows
+	//
+	// description:
+	//		TreeGrid currently only works on "simple" structures.  That is,
+	//		single-view structures with a single row in them.
+	//
+	//		The TreeGrid works using the concept of "levels" - level 0 are the
+	//		top-level items.
+	
+	// defaultOpen: Boolean
+	//		Whether or not we default to open (all levels).  This defaults to
+	//		false for grids with a treeModel.
+	defaultOpen: true,
+
+	// sortChildItems: Boolean
+	// 		If true, child items will be returned sorted according to the sorting
+	// 		properties of the grid.
+	sortChildItems: false,
+
+	// openAtLevels: Array
+	//		Which levels we are open at (overrides defaultOpen for the values
+	//		that exist here).  Its values can be a boolean (true/false) or an
+	//		integer (for the # of children to be closed if there are more than
+	//		that)
+	openAtLevels: [],
+	
+	// treeModel: dijit.tree.ForestStoreModel
+	//		A dijit.Tree model that will be used instead of using aggregates.
+	//		Setting this value will make the TreeGrid behave like a columnar
+	//		tree.  When setting this value, defaultOpen will default to false,
+	//		and openAtLevels will be ignored.
+	treeModel: null,
+	
+	// expandoCell: Integer
+	//		When used in conjunction with a treeModel (see above), this is a 0-based
+	//		index of the cell in which to place the actual expando
+	expandoCell: 0,
+	
+	// private values
+	// aggregator: Object
+	//		The aggregator class - it will be populated automatically if we
+	//		are a collapsable grid
+	aggregator: null,
+
+
+	// Override this to get our "magic" layout
+	_layoutClass: _TreeLayout,
+
+	createSelection: function(){
+		this.selection = new TreeSelection(this);
+	},
+
+	_childItemSorter: function(a, b, attribute, descending){
+		var av = this.store.getValue(a, attribute);
+		var bv = this.store.getValue(b, attribute);
+		if(av != bv){
+			return av < bv == descending ? 1 : -1;
+		}
+		return 0;
+	},
+
+	_onNew: function(item, parentInfo){
+		if(!parentInfo || !parentInfo.item){
+			this.inherited(arguments);
+		}else{
+			var idx = this.getItemIndex(parentInfo.item);
+			if(typeof idx == "string"){
+				this.updateRow(idx.split('/')[0]);
+			}else if(idx > -1){
+				this.updateRow(idx);
+			}
+		}
+	},
+
+	_onSet: function(item, attribute, oldValue, newValue){
+		this._checkUpdateStatus();
+		if(this.aggregator){
+			this.aggregator.clearSubtotalCache();
+		}
+		var idx = this.getItemIndex(item);
+		if(typeof idx == "string"){
+			this.updateRow(idx.split('/')[0]);
+		}else if(idx > -1){
+			this.updateRow(idx);
+		}
+	},
+
+	_onDelete: function(item){
+		this._cleanupExpandoCache(this._getItemIndex(item, true), this.store.getIdentity(item), item);
+		this.inherited(arguments);
+	},
+
+	_cleanupExpandoCache: function(index, identity, item){},
+
+	_addItem: function(item, index, noUpdate, dontUpdateRoot){
+		// add our root items to the root of the model's children
+		// list since we don't query the model
+		if(!dontUpdateRoot && this.model && array.indexOf(this.model.root.children, item) == -1){
+			this.model.root.children[index] = item;
+		}
+		this.inherited(arguments);
+	},
+
+	getItem: function(/*integer|Array|String*/ idx){
+		// summary:
+		//		overridden so that you can pass in a '/' delimited string of indexes to get the
+		//		item based off its path...that is, passing in "1/3/2" will get the
+		//		3rd (0-based) child from the 4th child of the 2nd top-level item.
+		var isArray = lang.isArray(idx);
+		if(lang.isString(idx) && idx.indexOf('/')){
+			idx = idx.split('/');
+			isArray = true;
+		}
+		if(isArray && idx.length == 1){
+			idx = idx[0];
+			isArray = false;
+		}
+		if(!isArray){
+			return DataGrid.prototype.getItem.call(this, idx);
+		}
+		var s = this.store;
+		var itm = DataGrid.prototype.getItem.call(this, idx[0]);
+		var cf, i, j;
+		if(this.aggregator){
+			cf = this.aggregator.childFields||[];
+			if(cf){
+				for(i = 0; i < idx.length - 1 && itm; i++){
+					if(cf[i]){
+						itm = (s.getValues(itm, cf[i])||[])[idx[i + 1]];
+					}else{
+						itm = null;
+					}
+				}
+			}
+		}else if(this.treeModel){
+			cf = this.treeModel.childrenAttrs||[];
+			if(cf&&itm){
+				for(i=1, il=idx.length; (i<il) && itm; i++) {
+					for(j=0, jl=cf.length; j<jl; j++) {
+						if(cf[j]){
+							itm = (s.getValues(itm, cf[j])||[])[idx[i]];
+						}else{
+							itm = null;
+						}
+						if(itm){ break; }
+					}
+				}
+			}
+		}
+		return itm || null;
+	},
+
+	_getItemIndex: function(item, isDeleted){
+		if(!isDeleted && !this.store.isItem(item)){
+			return -1;
+		}
+		var idx = this.inherited(arguments);
+		if(idx == -1){
+			var idty = this.store.getIdentity(item);
+			return this._by_idty_paths[idty] || -1;
+		}
+		return idx;
+	},
+	
+	postMixInProperties: function(){
+		if(this.treeModel && !("defaultOpen" in this.params)){
+			// Default open to false for tree models, true for other tree
+			// grids.
+			this.defaultOpen = false;
+		}
+		var def = this.defaultOpen;
+		this.openAtLevels = array.map(this.openAtLevels, function(l){
+			if(typeof l == "string"){
+				switch(l.toLowerCase()){
+					case "true":
+						return true;
+						break;
+					case "false":
+						return false;
+						break;
+					default:
+						var r = parseInt(l, 10);
+						if(isNaN(r)){
+							return def;
+						}
+						return r;
+						break;
+				}
+			}
+			return l;
+		});
+		this._by_idty_paths = {};
+		this.inherited(arguments);
+	},
+	
+    postCreate: function(){
+        this.inherited(arguments);
+		if(this.treeModel){
+			this._setModel(this.treeModel);
+		}
+    },
+
+	setModel: function(treeModel){
+		this._setModel(treeModel);
+		this._refresh(true);
+	},
+	
+	_setModel: function(treeModel){
+		if(treeModel && (!ForestStoreModel || !(treeModel instanceof ForestStoreModel))){
+			throw new Error("dojox.grid.TreeGrid: treeModel must be an instance of dijit.tree.ForestStoreModel");
+		}
+		this.treeModel = treeModel;
+		domClass.toggle(this.domNode, "dojoxGridTreeModel", this.treeModel ? true : false);
+		this._setQuery(treeModel ? treeModel.query : null);
+		this._setStore(treeModel ? treeModel.store : null);
+	},
+
+	createScroller: function(){
+		this.inherited(arguments);
+		this.scroller._origDefaultRowHeight = this.scroller.defaultRowHeight;
+	},
+	
+	createManagers: function(){
+		// summary:
+		//		create grid managers for various tasks including rows, focus, selection, editing
+
+		// row manager
+		this.rows = new _RowManager(this);
+		// focus manager
+		this.focus = new _TreeFocusManager(this);
+		// edit manager
+		this.edit = new _EditManager(this);
+	},
+
+	_setStore: function(store){
+		this.inherited(arguments);
+		if(this.treeModel&&!this.treeModel.root.children){
+			this.treeModel.root.children = [];
+		}
+		if(this.aggregator){
+			this.aggregator.store = store;
+		}
+	},
+	
+	getDefaultOpenState: function(cellDef, item){
+		// summary:
+		//		Returns the default open state for the given definition and item
+		//		It reads from the openAtLevels and defaultOpen values of the
+		//		grid to calculate if the given item should default to open or
+		//		not.
+		var cf;
+		var store = this.store;
+		if(this.treeModel){ return this.defaultOpen; }
+		if(!cellDef || !store || !store.isItem(item) ||
+				!(cf = this.aggregator.childFields[cellDef.level])){
+			return this.defaultOpen;
+		}
+		if(this.openAtLevels.length > cellDef.level){
+			var dVal = this.openAtLevels[cellDef.level];
+			if(typeof dVal == "boolean"){
+				return dVal;
+			}else if(typeof dVal == "number"){
+				return (store.getValues(item, cf).length <= dVal);
+			}
+		}
+		return this.defaultOpen;
+	},
+	onStyleRow: function(row){
+		if(!this.layout._isCollapsable){
+			this.inherited(arguments);
+			return;
+		}
+		var base = domAttr.get(row.node, 'dojoxTreeGridBaseClasses');
+		if(base){
+			row.customClasses = base;
+		}
+		var i = row;
+		var tagName = i.node.tagName.toLowerCase();
+		i.customClasses += (i.odd?" dojoxGridRowOdd":"") +
+						   (i.selected&&tagName=='tr'?" dojoxGridRowSelected":"") +
+						   (i.over&&tagName=='tr'?" dojoxGridRowOver":"");
+		this.focus.styleRow(i);
+		this.edit.styleRow(i);
+	},
+	styleRowNode: function(inRowIndex, inRowNode){
+		if(inRowNode){
+			if(inRowNode.tagName.toLowerCase() == 'div' && this.aggregator){
+				query("tr[dojoxTreeGridPath]", inRowNode).forEach(function(rowNode){
+					this.rows.styleRowNode(domAttr.get(rowNode, 'dojoxTreeGridPath'), rowNode);
+				},this);
+			}
+			this.rows.styleRowNode(inRowIndex, inRowNode);
+		}
+	},
+	onCanSelect: function(inRowIndex){
+		var nodes = query("tr[dojoxTreeGridPath='" + inRowIndex + "']", this.domNode);
+		if(nodes.length){
+			if(domClass.contains(nodes[0], 'dojoxGridSummaryRow')){
+				return false;
+			}
+		}
+		return this.inherited(arguments);
+	},
+	onKeyDown: function(e){
+		if(e.altKey || e.metaKey){
+			return;
+		}
+		switch(e.keyCode){
+			case keys.UP_ARROW:
+				if(!this.edit.isEditing() && this.focus.rowIndex != "0"){
+					event.stop(e);
+					this.focus.move(-1, 0);
+				}
+				break;
+			case keys.DOWN_ARROW:
+				var currPath = new TreePath(this.focus.rowIndex, this);
+				var lastPath = new TreePath(this.rowCount-1, this);
+				lastPath = lastPath.lastChild(true);
+				if(!this.edit.isEditing() && currPath.toString() != lastPath.toString()){
+					event.stop(e);
+					this.focus.move(1, 0);
+				}
+				break;
+			default:
+				this.inherited(arguments);
+				break;
+		}
+	},
+	canEdit: function(inCell, inRowIndex){
+		var node = inCell.getNode(inRowIndex);
+		return node && this._canEdit;
+	},
+	doApplyCellEdit: function(inValue, inRowIndex, inAttrName){
+		var item = this.getItem(inRowIndex);
+		var oldValue = this.store.getValue(item, inAttrName);
+		if(typeof oldValue == 'number'){
+			inValue = isNaN(inValue) ? inValue : parseFloat(inValue);
+		}else if(typeof oldValue == 'boolean'){
+			inValue = inValue == 'true' ? true : inValue == 'false' ? false : inValue;
+		}else if(oldValue instanceof Date){
+			var asDate = new Date(inValue);
+			inValue = isNaN(asDate.getTime()) ? inValue : asDate;
+		}
+		this.store.setValue(item, inAttrName, inValue);
+		this.onApplyCellEdit(inValue, inRowIndex, inAttrName);
+	}
+});
+TreeGrid.markupFactory = function(props, node, ctor, cellFunc){
+	var widthFromAttr = function(n){
+		var w = domAttr.get(n, "width")||"auto";
+		if((w != "auto")&&(w.slice(-2) != "em")&&(w.slice(-1) != "%")){
+			w = parseInt(w, 10)+"px";
+		}
+		return w;
+	};
+	
+	var cellsFromMarkup = function(table){
+		var rows;
+		// Don't support colgroup on our grid - single view, single row only
+		if(table.nodeName.toLowerCase() == "table" &&
+					query("> colgroup", table).length === 0 &&
+					(rows = query("> thead > tr", table)).length == 1){
+			var tr = rows[0];
+			return query("> th", rows[0]).map(function(th){
+				// Grab type and field (the only ones that are shared
+				var cell = {
+					type: lang.trim(domAttr.get(th, "cellType")||""),
+					field: lang.trim(domAttr.get(th, "field")||"")
+				};
+				if(cell.type){
+					cell.type = lang.getObject(cell.type);
+				}
+				
+				var subTable = query("> table", th)[0];
+				if(subTable){
+					// If we have a subtable, we are an aggregate and a summary cell
+					cell.name = "";
+					cell.children = cellsFromMarkup(subTable);
+					if(domAttr.has(th, "itemAggregates")){
+						cell.itemAggregates = array.map(domAttr.get(th, "itemAggregates").split(","), function(v){
+							return lang.trim(v);
+						});
+					}else{
+						cell.itemAggregates = [];
+					}
+					if(domAttr.has(th, "aggregate")){
+						cell.aggregate = domAttr.get(th, "aggregate");
+					}
+					cell.type = cell.type || dojox.grid.cells.SubtableCell;
+				}else{
+					// Grab our other stuff we need (mostly what's in the normal
+					// Grid)
+					cell.name = lang.trim(domAttr.get(th, "name")||th.innerHTML);
+					if(domAttr.has(th, "width")){
+						cell.width = widthFromAttr(th);
+					}
+					if(domAttr.has(th, "relWidth")){
+						cell.relWidth = window.parseInt(domAttr.get(th, "relWidth"), 10);
+					}
+					if(domAttr.has(th, "hidden")){
+						cell.hidden = domAttr.get(th, "hidden") == "true";
+					}
+					cell.field = cell.field||cell.name;
+					DataGrid.cell_markupFactory(cellFunc, th, cell);
+					cell.type = cell.type || dojox.grid.cells.Cell;
+				}
+				if(cell.type && cell.type.markupFactory){
+					cell.type.markupFactory(th, cell);
+				}
+				return cell;
+			});
+		}
+		return [];
+	};
+	
+	var rows;
+	if(	!props.structure ){
+		var row = cellsFromMarkup(node);
+		if(row.length){
+			// Set our structure here - so that we don't try and set it in the
+			// markup factory
+			props.structure = [{__span: Infinity, cells:[row]}];
+		}
+	}
+	return DataGrid.markupFactory(props, node, ctor, cellFunc);
+};
+
+return TreeGrid;
+
+});