gridx-rails 1.2.1 → 1.3.0.pre.alpha

data/app/assets/javascripts/gridx/core/model/cache/Sync.js

@@ -1,17 +1,22 @@
 define([
-	"dojo/_base/declare",
-	"dojo/_base/lang",
-	"dojo/_base/Deferred",
-	"./_Cache"
-], function(declare, lang, Deferred, _Cache){
+	'dojo/_base/declare',
+	'dojo/_base/array',
+	'dojo/_base/lang',
+	'dojo/_base/Deferred',
+	'../_Extension'
+], function(declare, array, lang, Deferred, _Extension){
 
 /*=====
-	return declare(_Cache, {
+	return declare(_Extension, function(){
 		// summary:
-		//		Implement a cache for client side store.
+		//		Abstract base cache class, providing cache data structure and some common cache functions.
 	});
 =====*/
 
+	var hitch = lang.hitch,
+		mixin = lang.mixin,
+		indexOf = array.indexOf;
+
 	function fetchChildren(self){
 		var s = self._struct,
 			pids = s[''].slice(1),
@@ -27,9 +32,46 @@ define([
 		}
 	}
 
-	return declare(_Cache, {
-		keep: function(){},
-		free: function(){},
+	return declare(_Extension, {
+		constructor: function(model, args){
+			var t = this;
+			t.setStore(args.store);
+			t.columns = lang.mixin({}, args.columnsById || args._columnsById);
+			t._mixinAPI('byIndex', 'byId', 'indexToId', 'idToIndex', 'size', 'treePath', 'rootId', 'parentId',
+				'hasChildren', 'children', 'keep', 'free', 'layerId', 'setLayer', 'layerUp');
+		},
+
+		destroy: function(){
+			this.inherited(arguments);
+			this._layer = '';
+			this.clear();
+		},
+
+		setStore: function(store){
+			var t = this,
+				c = 'aspect',
+				old = store.fetch;
+			//Disconnect store events.
+			t.destroy();
+			t._cnnts = [];
+			t.store = store;
+			if(!old && store.notify){
+				//The store implements the dojo.store.Observable API
+				t[c](store, 'notify', function(item, id){
+					if(item === undefined){
+						t._onDelete(id);
+					}else if(id === undefined){
+						t._onNew(item);
+					}else{
+						t._onSet(item);
+					}
+				});
+			}else{
+				t[c](store, old ? "onSet" : "put", "_onSet");
+				t[c](store, old ? "onNew" : "add", "_onNew");
+				t[c](store, old ? "onDelete" : "remove", "_onDelete");
+			}
+		},
 
 		when: function(args, callback){
 			var d = new Deferred();
@@ -44,8 +86,138 @@ define([
 			return d;
 		},
 
-		//Private---------------------------------------------
-		_init: function(/*method, args*/){
+		//Public----------------------------------------------
+		clear: function(){
+			var t = this;
+			t._filled = 0;
+			t._priority = [];
+			t._struct = {};
+			t._cache = {};
+			t._size = {};
+			//virtual root node, with id ''.
+			t._struct[''] = [];
+			t._size[''] = -1;
+			t.totalSize = undefined;
+		},
+
+		layerId: function(){
+			return this._layer;
+		},
+
+		setLayer: function(id){
+			this._layer = id;
+			this.model._msg('storeChange');
+			this.model._onSizeChange();
+		},
+
+		layerUp: function(){
+			var pid = this.parentId(this._layer);
+			this.setLayer(pid);
+		},
+
+		byIndex: function(index, parentId){
+			this._init();
+			return this._cache[this.indexToId(index, parentId)];
+		},
+
+		byId: function(id){
+			this._init();
+			return this._cache[id];
+		},
+
+		indexToId: function(index, parentId){
+			this._init();
+			var items = this._struct[this.model.isId(parentId) ? parentId : this.layerId()];
+			return typeof index == 'number' && index >= 0 ? items && items[index + 1] : undefined;
+		},
+
+		idToIndex: function(id){
+			this._init();
+			var s = this._struct,
+				pid = s[id] && s[id][0],
+				index = indexOf(s[pid] || [], id);
+			return index > 0 ? index - 1 : -1;
+		},
+
+		treePath: function(id){
+			this._init();
+			var s = this._struct,
+				path = [];
+			while(id !== undefined){
+				path.unshift(id);
+				id = s[id] && s[id][0];
+			}
+			if(path[0] !== ''){
+				path = [];
+			}else{
+				path.pop();
+			}
+			return path;
+		},
+
+		rootId: function(id){
+			var path = this.treePath(id);
+			if(path.length > 1){
+				return path[1];
+			}else if(!path.length){
+				return null;
+			}
+			return id;
+		},
+
+		parentId: function(id){
+			return this.treePath(id).pop();
+		},
+
+		hasChildren: function(id){
+			var t = this,
+				s = t.store,
+				c;
+			t._init();
+			c = t.byId(id);
+			return s.hasChildren && s.hasChildren(id, c && c.item) && s.getChildren;
+		},
+
+		children: function(parentId){
+			this._init();
+			parentId = this.model.isId(parentId) ? parentId : '';
+			var size = this._size[parentId],
+				children = [],
+				i = 0;
+			for(; i < size; ++i){
+				children.push(this.indexToId(i, parentId));
+			}
+			return children;
+		},
+
+		size: function(parentId){
+			this._init();
+			var s = this._size[this.model.isId(parentId) ? parentId : this.layerId()];
+			return s >= 0 ? s : -1;
+		},
+
+		keep: function(){},
+		free: function(){},
+
+		//Events--------------------------------------------
+		onBeforeFetch: function(){},
+		onAfterFetch: function(){},
+		onLoadRow: function(){},
+
+		onSetColumns: function(columns){
+			var t = this, id, c, colId, col;
+			t.columns = lang.mixin({}, columns);
+			for(id in t._cache){
+				c = t._cache[id];
+				for(colId in columns){
+					col = columns[colId];
+					c.data[colId] = t._formatCell(c.rawData, id, col.id);
+				}
+			}
+		},
+
+		//Protected-----------------------------------------
+		_init: function(){
 			var t = this;
 			if(!t._filled){
 				t._storeFetch({ start: 0 });
@@ -54,6 +226,236 @@ define([
 				}
 				t.model._onSizeChange();
 			}
+		},
+
+		_itemToObject: function(item){
+			var s = this.store,
+				obj = {};
+			if(s.fetch){
+				array.forEach(s.getAttributes(item), function(attr){
+					obj[attr] = s.getValue(item, attr);
+				});
+				return obj;	
+			}
+			return item;
+		},
+
+		_formatCell: function(rawData, rowId, colId){
+			var col = this.columns[colId];
+			return col.formatter ? col.formatter(rawData, rowId) : rawData[col.field || colId];
+		},
+
+		_formatRow: function(rowData, rowId){
+			var cols = this.columns, res = {}, colId;
+			for(colId in cols){
+				res[colId] = this._formatCell(rowData, rowId, colId);
+			}
+			return res;
+		},
+
+		_addRow: function(id, index, rowData, item, parentId){
+			var t = this,
+				st = t._struct,
+				pr = t._priority,
+				pid = t.model.isId(parentId) ? parentId : '',
+				ids = st[pid],
+				i;
+			if(!ids){
+				throw new Error("Fatal error of _Cache._addRow: parent item " + pid + " of " + id + " is not loaded");
+			}
+			var oldId = ids[index + 1];
+			if(t.model.isId(oldId) && oldId !== id){
+				console.error("Error of _Cache._addRow: different row id " + id + " and " + ids[index + 1] + " for same row index " + index);
+			}
+			ids[index + 1] = id;
+			st[id] = st[id] || [pid];
+			if(pid === ''){
+				i = indexOf(pr, id);
+				if(i >= 0){
+					pr.splice(i, 1);
+				}
+				pr.push(id);
+			}
+			t._cache[id] = {
+				data: t._formatRow(rowData, id),
+				rawData: rowData,
+				item: item
+			};
+			t.onLoadRow(id);
+		},
+
+		_storeFetch: function(options, onFetched){
+//            console.debug("\tFETCH parent: ",
+//                    options.parentId, ", start: ",
+//                    options.start || 0, ", count: ",
+//                    options.count, ", end: ",
+//                    options.count && (options.start || 0) + options.count - 1, ", options:",
+//                    this.options);
+
+			var t = this,
+				s = t.store,
+				d = new Deferred(),
+				parentId = t.model.isId(options.parentId) ? options.parentId : '',
+				req = mixin({}, t.options || {}, options),
+				onError = hitch(d, d.errback),
+				results;
+			function onBegin(size){
+				t._size[parentId] = parseInt(size, 10);
+			}
+			function onComplete(items){
+				//FIXME: store does not support getting total size after filter/query, so we must change the protocal a little.
+				if(items.ioArgs && items.ioArgs.xhr){
+					var range = results.ioArgs.xhr.getResponseHeader("Content-Range");
+					if(range && (range = range.match(/(.+)\//))){
+						t.totalSize = +range[1];
+					}else{
+						t.totalSize = undefined;
+					}
+				}
+				try{
+					var start = options.start || 0,
+						i = 0,
+						item;
+					for(; item = items[i]; ++i){
+						t._addRow(s.getIdentity(item), start + i, t._itemToObject(item), item, parentId);
+					}
+					d.callback();
+				}catch(e){
+					d.errback(e);
+				}
+			}
+			t._filled = 1;
+			t.onBeforeFetch(req);
+			if(parentId === ''){
+				if(s.fetch){
+					s.fetch(mixin(req, {
+						onBegin: onBegin,
+						onComplete: onComplete,
+						onError: onError
+					}));
+				}else{
+					results = s.query(req.query || {}, req);
+					Deferred.when(results.total, onBegin);
+					Deferred.when(results, onComplete, onError);
+				}
+			}else if(t.hasChildren(parentId)){
+				results = s.getChildren(t.byId(parentId).item, req);
+				if('total' in results){
+					Deferred.when(results.total, onBegin);
+				}else{
+					Deferred.when(results, function(results){
+						onBegin(results.length);
+					});
+				}
+				Deferred.when(results, onComplete, onError);
+			}else{
+				d.callback();
+			}
+			d.then(function(){
+				t.onAfterFetch();
+			});
+			return d;
+		},
+
+		//--------------------------------------------------------------------------
+		_onSet: function(item){
+			var t = this,
+				id = t.store.getIdentity(item),
+				index = t.idToIndex(id),
+				path = t.treePath(id),
+				old = t._cache[id];
+			if(path.length){
+				t._addRow(id, index, t._itemToObject(item), item, path.pop());
+			}
+			t.onSet(id, index, t._cache[id], old);
+		},
+
+		_onNew: function(item, parentInfo){
+			var t = this,
+				s = t.store,
+				row = t._itemToObject(item),
+				parentItem = parentInfo && parentInfo[s.fetch ? 'item' : 'parent'],
+				parentId = parentItem ? s.getIdentity(parentItem) : '',
+				id = s.getIdentity(item),
+				size = t._size[''];
+			t.clear();
+			t.onNew(id, 0, {
+				data: t._formatRow(row, id),
+				rawData: row,
+				item: item
+			});
+			if(!parentItem && size >= 0){
+				t._size[''] = size + 1;
+				if(t.totalSize >= 0){
+					t.totalSize = size + 1;
+				}
+				t.model._onSizeChange();
+			}
+		},
+
+		_onDelete: function(item){
+			var t = this,
+				s = t.store,
+				st = t._struct,
+				id = s.fetch ? s.getIdentity(item) : item,
+				path = t.treePath(id);
+			if(path.length){
+				var children, i, j,
+					ids = [id],
+					parentId = path[path.length - 1],
+					sz = t._size,
+					size = sz[''],
+					index = indexOf(st[parentId], id);
+				//This must exist, because we've already have treePath
+				st[parentId].splice(index, 1);
+				--sz[parentId];
+
+				for(i = 0; i < ids.length; ++i){
+					children = st[ids[i]];
+					if(children){
+						for(j = children.length - 1; j > 0; --j){
+							ids.push(children[j]);
+						}
+					}
+				}
+				for(i = ids.length - 1; i >= 0; --i){
+					j = ids[i];
+					delete t._cache[j];
+					delete st[j];
+					delete sz[j];
+				}
+				i = indexOf(t._priority, id);
+				if(i >= 0){
+					t._priority.splice(i, 1);
+				}
+				t.onDelete(id, index - 1, path);
+				if(!parentId && size >= 0){
+					sz[''] = size - 1;
+					if(t.totalSize >= 0){
+						t.totalSize = size - 1;
+					}
+					t.model._onSizeChange();
+				}
+			}else{
+				//FIXME: Don't know what to do if the deleted row was not loaded.
+				t.clear();
+				t.onDelete(id);
+//                var onBegin = hitch(t, _onBegin),
+//                    req = mixin({}, t.options || {}, {
+//                        start: 0,
+//                        count: 1
+//                    });
+//                setTimeout(function(){
+//                    if(s.fetch){
+//                        s.fetch(mixin(req, {
+//                            onBegin: onBegin
+//                        }));
+//                    }else{
+//                        var results = s.query(req.query, req);
+//                        Deferred.when(results.total, onBegin);
+//                    }
+//                }, 10);
+			}
 		}
 	});
 });

data/app/assets/javascripts/gridx/core/model/extensions/Mark.js

@@ -276,7 +276,6 @@ define([
 				if(!toMark){
 					delete t._byId[type][id];
 				}
-				//console.log('mark change: ', id, ', state: ', oldState, ' => ', toMark);
 				m.onMarkChange(id, t.states[toMark || 0], t.states[oldState || 0], type);
 			}
 		},
@@ -289,26 +288,23 @@ define([
 			for(var i = treePath.length - 1; i > 0; --i){
 				var pid = treePath[i],
 					oldState = byId[pid],
-					siblings = array.filter(mm._call('children', [pid]), function(childId){
-						return t._isMarkable(type, childId);
-					}),
+					siblings = mm._call('children', [pid]),
 					markCount = array.filter(siblings, function(childId){
 						return last[childId] = byId[childId];
 					}).length,
 					fullCount = array.filter(siblings, function(childId){
 						return byId[childId] == 2;
 					}).length;
-				if(t._isMarkable(type, pid)){
-					if(fullCount != 0 && fullCount == siblings.length && oldState != 2){
-						byId[pid] = 2; //none|partial -> all
-					}else if(!markCount && oldState){
-						delete byId[pid]; //all|partial -> none
-					}else if(markCount && fullCount < siblings.length && oldState != 1){
-						byId[pid] = 1; //all|none -> partial
-					}
-					if(!noEvent){
-						t._fireEvent(pid, type, byId[pid], oldState);
-					}
+				// if(t._isMarkable(type, pid)){
+				if(fullCount != 0 && fullCount == siblings.length && oldState != 2){
+					byId[pid] = 2; //none|partial -> all
+				}else if(!markCount && oldState){
+					delete byId[pid]; //all|partial -> none
+				}else if(markCount && fullCount < siblings.length && oldState != 1){
+					byId[pid] = 1; //all|none -> partial
+				}
+				if(!noEvent){
+					t._fireEvent(pid, type, byId[pid], oldState);
 				}
 			}
 		},
@@ -341,11 +337,9 @@ define([
 				while(ids.length){
 					childId = ids.shift();
 					oldState = byId[childId] || 0;
-					if(t._isMarkable(tp, childId)){
-						newState = byId[childId] = toMark == 1 ? last[childId] || 0 : toMark;
-						if(!noEvent){
-							t._fireEvent(childId, tp, newState, oldState);
-						}
+					newState = byId[childId] = toMark == 1 ? last[childId] || 0 : toMark;
+					if(!noEvent){
+						t._fireEvent(childId, tp, newState, oldState);
 					}
 					if(mm._call('hasChildren', [childId])){
 						children = mm._call('children', [childId]);

data/app/assets/javascripts/gridx/core/model/extensions/Modify.js

@@ -140,11 +140,7 @@ define([
 		byId: function(id){
 			var t = this,
 				c = t.inner._call('byId', arguments);
-				
-			if(!c || !t._lazyRawData[id]){ 
-				return c; 
-			}
-			
+			if(!c){ return c; }
 			var d = lang.mixin({}, c);
 			d.rawData = lang.mixin({}, d.rawData, t._lazyRawData[id]);
 			d.data = lang.mixin({}, d.data, t._lazyData[id]);		
@@ -155,12 +151,9 @@ define([
 			var t = this,
 				c = t.inner._call('byIndex', arguments),
 				id = t.inner._call('indexToId', arguments);
-
-			if(!c || !t._lazyRawData[id]){ 
-				return c; 
-			}
-			
+			if(!c){ return c; }
 			var d = lang.mixin({}, c);
+			
 			d.rawData = lang.mixin({}, d.rawData, t._lazyRawData[id]);
 			d.data = lang.mixin({}, d.data, t._lazyData[id]);
 			return d;

data/app/assets/javascripts/gridx/modules/AutoPagedBody.js

@@ -0,0 +1,100 @@
+define([
+	"dojo/_base/declare",
+	"dojo/_base/lang",
+	"dojo/dom-class",
+	"dojo/_base/Deferred",
+	"./Body",
+	"./_PagedBodyMixin"
+], function(declare, lang, domClass, Deferred, Body, _PagedBodyMixin){
+
+/*=====
+	return declare(Body, {
+		// summary:
+		//		module name: body.
+		//		
+		// description:
+		//		
+	});
+=====*/
+
+	return declare([Body, _PagedBodyMixin], {
+		preload: function(){
+			this.inherited(arguments);
+			var t = this,
+				g = t.grid,
+				dn = t.domNode,
+				load = function(){
+					t._load(1);
+				};
+			t.connect(dn, 'onscroll', function(e){
+				var lastNode = dn.lastChild;
+				if(lastNode.offsetTop + lastNode.offsetHeight <= dn.scrollTop + dn.offsetHeight){
+					clearTimeout(t._loadHandler);
+					t._loadHandler = setTimeout(load, 10);
+				}
+			});
+			t.aspect(g, '_onResizeEnd', function(){
+				if(t._checkSpace()){
+					t._load(1);
+				}
+			});
+			g.vScroller.loaded.then(function(){
+				var scrollable = g.vScroller._scrollable;
+				if(scrollable){
+					t.aspect(scrollable, 'slideTo', function(to, duration){
+						if(to.y < g.mainNode.offsetHeight - g.bodyNode.offsetHeight + dn.lastChild.offsetHeight){
+							clearTimeout(t._loadHandler);
+							t._loadHandler = setTimeout(load, duration * 1000);
+						}
+					});
+				}
+			});
+		},
+
+		_checkSpace: function(){
+			var bn = this.domNode;
+			return bn.lastChild == this._bottomNode && bn.lastChild.offsetTop + bn.lastChild.offsetHeight < bn.scrollTop + bn.offsetHeight;
+		},
+
+		onRender: function(/*start, count*/){
+			var t = this;
+			t.inherited(arguments);
+			if(t._checkSpace()){
+				t._load(1);
+			}
+		},
+
+		createBottom: function(bottomNode){
+			bottomNode.innerHTML = '<span class="gridxLoadingMore"></span>' + this.arg('loadMoreLoadingLabel', this.grid.nls.loadMoreLoading);
+		},
+
+		refresh: function(){
+			var inherited = lang.hitch(this, this.inherited, arguments);
+			if(this.arg('quickRefresh')){
+				domClass.add(this.grid.loadingNode, 'gridxLoading');
+				var scrollable = this.grid.vScroller._scrollable;
+				if(scrollable){
+					var pos = scrollable.getPos();
+					scrollable.scrollTo({x: pos.x, y: 0});
+				}
+				var d = new Deferred();
+				this.grid.view.updateRootRange(0, this.pageSize).then(function(){
+					inherited().then(function(){
+						d.callback();
+					}, function(e){
+						d.errback(e);
+					});
+				});
+				return d;
+			}else{
+				return inherited();
+			}
+		},
+
+		_busy: function(){},
+
+		_onLoadFinish: function(isPost, start, count, callback){
+			callback();
+		}
+	});
+});