gridx-rails 1.1.0

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

@@ -0,0 +1,386 @@
+define([
+	'dojo/_base/declare',
+	'dojo/_base/array',
+	'dojo/_base/lang',
+	'dojo/_base/Deferred',
+	'../_Extension'
+], function(declare, array, lang, Deferred, _Extension){
+
+/*=====
+	return declare(_Extension, function(){
+		// summary:
+		//		Abstract base cache class, providing cache data structure and some common cache functions.
+	});
+=====*/
+
+	var hitch = lang.hitch,
+		mixin = lang.mixin,
+		indexOf = array.indexOf;
+
+	return declare(_Extension, {
+		constructor: function(model, args){
+			var t = this;
+			t.setStore(args.store);
+			t.columns = lang.mixin({}, args._columnsById);
+			t._mixinAPI('byIndex', 'byId', 'indexToId', 'idToIndex', 'size', 'treePath', 'rootId', 'parentId',
+				'hasChildren', 'children', 'keep', 'free');
+		},
+
+		destroy: function(){
+			this.inherited(arguments);
+			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");
+			}
+		},
+
+		//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;
+		},
+
+		byIndex: function(index, parentId){
+			this._init('byIndex', arguments);
+			return this._cache[this.indexToId(index, parentId)];
+		},
+
+		byId: function(id){
+			this._init('byId', arguments);
+			return this._cache[id];
+		},
+
+		indexToId: function(index, parentId){
+			this._init('indexToId', arguments);
+			var items = this._struct[this.model.isId(parentId) ? parentId : ''];
+			return typeof index == 'number' && index >= 0 ? items && items[index + 1] : undefined;
+		},
+
+		idToIndex: function(id){
+			this._init('idToIndex', arguments);
+			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('treePath', arguments);
+			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('hasChildren', arguments);
+			c = t.byId(id);
+			return s.hasChildren && s.hasChildren(id, c && c.item) && s.getChildren;
+		},
+
+		children: function(parentId){
+			this._init('children', arguments);
+			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('size', arguments);
+			var s = this._size[this.model.isId(parentId) ? parentId : ''];
+			return s >= 0 ? s : -1;
+		},
+
+		//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(col.id, c.rawData);
+				}
+			}
+		},
+
+		//Protected-----------------------------------------
+		_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(colId, rawData){
+			var col = this.columns[colId];
+			return col.formatter ? col.formatter(rawData) : rawData[col.field || colId];
+		},
+
+		_formatRow: function(rowData){
+			var cols = this.columns, res = {}, colId;
+			for(colId in cols){
+				res[colId] = this._formatCell(colId, rowData);
+			}
+			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),
+				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){
+				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) : '',
+				size = t._size[''];
+			t.clear();
+			t.onNew(s.getIdentity(item), 0, {
+				data: t._formatRow(row),
+				rawData: row,
+				item: item
+			});
+			if(!parentItem && size >= 0){
+				t._size[''] = 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;
+					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/ClientFilter.js

@@ -0,0 +1,303 @@
+define([
+	"dojo/_base/declare",
+	"dojo/_base/array",
+	"dojo/_base/lang",
+	"dojo/_base/Deferred",
+	/*====='../Model',=====*/
+	'../_Extension'
+], function(declare, array, lang, Deferred,
+	/*=====Model, =====*/
+	_Extension){
+
+/*=====
+	Model.filter = function(){};
+	Model.hasFilter = function(){};
+	Model.onFilterProgress = function(){};
+	
+	return declare(_Extension, {
+		// summary:
+		//		Filtering grid data at client side.
+	});
+=====*/
+
+	var hitch = lang.hitch,
+		forEach = array.forEach,
+		indexOf = array.indexOf;
+
+	return declare(_Extension, {
+		// Not compatible with Map extension!
+		name: 'clientFilter',
+
+		priority: 20,
+
+		constructor: function(model, args){
+			this.pageSize = args.pageSize || 100;
+			this._mixinAPI('filter', 'hasFilter');
+			model.onFilterProgress = function(){};
+			this.aspect(model, '_msg', '_receiveMsg');
+			this.aspect(model, 'setStore', 'clear');
+		},
+
+		//Public---------------------------------------------------------------------
+
+		//pageSize: 100,
+
+		clear: function(){
+			this._ids = 0;
+			this._indexes = {};
+		},
+
+		filter: function(checker){
+			this.model._addCmd({
+				name: '_cmdFilter',
+				scope: this,
+				args: arguments,
+				async: 1
+			});
+		},
+
+		hasFilter: function(){
+			return !!this._ids;
+		},
+
+		byIndex: function(index, parentId){
+			var t = this,
+				ids = t._ids,
+				inner = t.inner,
+				id = ids && ids[index];
+			return !t.model.isId(parentId) && ids ? t.model.isId(id) && inner._call('byId', [id]) : inner._call('byIndex', arguments);
+		},
+
+		byId: function(id){
+			return (this.ids && this._indexes[id] === undefined) ? null : this.inner._call('byId', arguments);
+		},
+
+		indexToId: function(index, parentId){
+			return !this.model.isId(parentId) && this._ids ? this._ids[index] : this.inner._call('indexToId', arguments);
+		},
+
+		idToIndex: function(id){
+			if(this._ids && this.inner._call('parentId', arguments) === ''){
+				var idx = indexOf(this._ids, id);
+				return idx >= 0 ? idx : undefined;
+			}
+			return this.inner._call('idToIndex', arguments);
+		},
+
+		size: function(parentId){
+			return !this.model.isId(parentId) && this._ids ? this._ids.length : this.inner._call('size', arguments);
+		},
+
+		when: function(args, callback){
+			var t = this,
+				f = function(){
+					if(t._ids){
+						t._mapWhenArgs(args);
+					}
+					return t.inner._call('when', [args, callback]);
+				};
+			if(t._refilter){
+				t._refilter = 0;
+				if(t._ids){
+					var d = new Deferred();
+					t._reFilter().then(function(){
+						f().then(hitch(d, d.callback), hitch(d, d.errback));
+					});
+					return d;
+				}
+			}
+			return f();
+		},
+
+		//Private---------------------------------------------------------------------
+		_cmdFilter: function(){
+			var a = arguments;
+			return this._filter.apply(this, a[a.length - 1]);
+		},
+
+		_filter: function(checker){
+			var t = this,
+				oldSize = t.size();
+			t.clear();
+			if(lang.isFunction(checker)){
+				var ids = [];
+				return t.model.scan({
+					start: 0,
+					pageSize: t.pageSize,
+					whenScope: t,
+					whenFunc: t.when
+				}, function(rows, s){
+					var i, id, row,
+						end = s + rows.length;
+					for(i = s; i < end; ++i){
+						id = t.indexToId(i);
+						row = t.byIndex(i);
+						if(row){
+							if(checker(row, id)){
+								ids.push(id);
+								t._indexes[id] = i;
+							}
+						}else{
+							break;
+						}
+					}
+				}).then(function(){
+					if(ids.length == t.size()){
+						//Filtered item size equals cache size, so filter is useless.
+						t.clear();
+					}else{
+						t._ids = ids;
+						t.model._msg('filter', ids);
+					}
+				}, 0, t.model.onFilterProgress);
+			}else{
+				var d = new Deferred();
+				d.callback();
+				return d;
+			}
+		},
+
+		_mapWhenArgs: function(args){
+			//Map ids and index ranges to what the store needs.
+			var t = this, ranges = [], size = t._ids.length;
+			args.id = array.filter(args.id, function(id){
+				return t._indexes[id] !== undefined;
+			});
+			forEach(args.range, function(r){
+				if(t.model.isId(r.parentId)){
+					ranges.push(r);
+				}else{
+					if(!r.count || r.count < 0){
+						//For open ranges, must limit the size because we know the filtered size here.
+						var cnt = size - r.start;
+						if(cnt <= 0){
+							return;
+						}
+						r.count = cnt;
+					}
+					for(var i = 0; i < r.count; ++i){
+						var idx = t._mapIndex(i + r.start);
+						if(idx !== undefined){
+							ranges.push({
+								start: idx,
+								count: 1
+							});
+						}
+					}
+				}
+			});
+			args.range = ranges;
+		},
+
+		_mapMoveArgs: function(args){
+			var t = this;
+			if(args.length == 3){
+				var indexes = [];
+				for(var i = args[0], end = args[0] + args[1]; i < end; ++i){
+					indexes.push(t._mapIndex(i));
+				}
+				args[0] = indexes;
+				args[1] = t._mapIndex(args[2]);
+				args.pop();
+			}else{
+				args[0] = array.map(args[0], function(index){
+					return t._mapIndex(index);
+				});
+				args[1] = t._mapIndex(args[1]);
+			}
+		},
+
+		_mapIndex: function(index){
+			return this._indexes[this._ids[index]];
+		},
+
+		_moveFiltered: function(start, count, target){
+			var t = this, size = t._ids.length;
+			if(start >= 0 && start < size && 
+				count > 0 && count < Infinity && 
+				target >= 0 && target < size && 
+				(target < start || target > start + count)){
+
+				var i, len, indexes = [];
+				for(i = start, len = start + count; i < len; ++i){
+					indexes.push(t._mapIndex(i));
+				}
+				t.inner._call('moveIndexes', [indexes, t._mapIndex(target)]);
+			}
+		},
+
+		_reFilter: function(){
+			var t = this;
+			return t.inner._call('when', [{
+				id: t._ids,
+				range: []
+			}, function(){
+				forEach(t._ids, function(id){
+					var idx = t.inner._call('idToIndex', [id]);
+					t._indexes[id] = idx;
+				});
+				t._ids.sort(function(a, b){
+					return t._indexes[a] - t._indexes[b];
+				});
+			}]);
+		},
+
+		_onMoved: function(map){
+			var t = this;
+			forEach(t._ids, function(id){
+				var oldIdx = t._indexes[id];
+				if(map[oldIdx] !== undefined){
+					t._indexes[id] = map[oldIdx];
+				}
+			});
+			t._ids.sort(function(a, b){
+				return t._indexes[a] - t._indexes[b];
+			});
+		},
+
+		_receiveMsg: function(msg, args){
+			var t = this;
+			if(t._ids){
+				if(msg == 'storeChange'){
+					t._refilter = 1;
+				}else if(msg == 'moved'){
+					t._onMoved(args);
+				}else if(msg == 'beforeMove'){
+					t._mapMoveArgs(args);
+				}
+			}
+		},
+
+		_onNew: function(id){
+			var t = this;
+			if(t._ids){
+				t._ids.push(id);
+				t._refilter = 1;
+			}
+			t.onNew.apply(t, arguments);
+		},
+
+		_onDelete: function(id, index, row){
+			var t = this, indexes = t._indexes, ids = t._ids;
+			if(ids){
+				var i = indexOf(ids, id),
+					idx = indexes[id];
+				if(i >= 0){
+					ids.splice(i, 1);
+				}
+				if(i >= 0 && idx !== undefined){
+					index = i;
+					for(i in indexes){
+						if(indexes[i] > idx){
+							--indexes[i];
+						}
+					}
+				}else{
+					index = undefined;
+					t._refilter = 1;
+				}
+			}
+			t.onDelete(id, index, row);
+		}
+	});
+});