wp/nwyj/.svn/pristine/2c/2c5db34760ca2e9cc10a9aa184f2f7008c4d0b18.svn-base

if (!dojo._hasResource['dojox.grid._data.model']) { // _hasResource checks added
													// by build. Do not use
													// _hasResource directly in
													// your code.
	dojo._hasResource['dojox.grid._data.model'] = true;
	dojo.provide('dojox.grid._data.model');
	dojo.require('dojox.grid._data.fields');

	dojo.declare("dojox.grid.data.Model", null, {
				// summary:
				// Base abstract grid data model.
				// Makes no assumptions about the structure of grid data.
				constructor : function(inFields, inData) {
					this.observers = [];
					this.fields = new dojox.grid.data.Fields();
					if (inFields) {
						this.fields.set(inFields);
					}
					this.setData(inData);
				},
				count : 0,
				updating : 0,
				// observers
				observer : function(inObserver, inPrefix) {
					this.observers.push({
								o : inObserver,
								p : inPrefix || 'model'
							});
				},
				notObserver : function(inObserver) {
					for (var i = 0, m, o; (o = this.observers[i]); i++) {
						if (o.o == inObserver) {
							this.observers.splice(i, 1);
							return;
						}
					}
				},
				notify : function(inMsg, inArgs) {
					if (!this.isUpdating()) {
						var a = inArgs || [];
						for (var i = 0, m, o; (o = this.observers[i]); i++) {
							m = o.p + inMsg, o = o.o;
							(m in o) && (o[m].apply(o, a));
						}
					}
				},
				// updates
				clear : function() {
					this.fields.clear();
					this.clearData();
				},
				beginUpdate : function() {
					this.updating++;
				},
				endUpdate : function() {
					if (this.updating) {
						this.updating--;
					}
					/*
					 * if(this.updating){ if(!(--this.updating)){ this.change(); } } }
					 */
				},
				isUpdating : function() {
					return Boolean(this.updating);
				},
				// data
				clearData : function() {
					this.setData(null);
				},
				// observer events
				change : function() {
					this.notify("Change", arguments);
				},
				insertion : function(/* index */) {
					this.notify("Insertion", arguments);
					this.notify("Change", arguments);
				},
				removal : function(/* keys */) {
					this.notify("Removal", arguments);
					this.notify("Change", arguments);
				},
				// insert
				insert : function(inData /* , index */) {
					if (!this._insert.apply(this, arguments)) {
						return false;
					}
					this.insertion.apply(this, dojo._toArray(arguments, 1));
					return true;
				},
				// remove
				remove : function(inData /* , index */) {
					if (!this._remove.apply(this, arguments)) {
						return false;
					}
					this.removal.apply(this, arguments);
					return true;
				},
				// sort
				canSort : function(/* (+|-)column_index+1, ... */) {
					return this.sort != null;
				},
				makeComparator : function(inIndices) {
					var idx, col, field, result = null;
					for (var i = inIndices.length - 1; i >= 0; i--) {
						idx = inIndices[i];
						col = Math.abs(idx) - 1;
						if (col >= 0) {
							field = this.fields.get(col);
							result = this.generateComparator(field.compare,
									field.key, idx > 0, result);
						}
					}
					return result;
				},
				sort : null,
				dummy : 0
			});

	dojo.declare("dojox.grid.data.Rows", dojox.grid.data.Model, {
				// observer events
				allChange : function() {
					this.notify("AllChange", arguments);
					this.notify("Change", arguments);
				},
				rowChange : function() {
					this.notify("RowChange", arguments);
				},
				datumChange : function() {
					this.notify("DatumChange", arguments);
				},
				// copyRow: function(inRowIndex); // abstract
				// update
				beginModifyRow : function(inRowIndex) {
					if (!this.cache[inRowIndex]) {
						this.cache[inRowIndex] = this.copyRow(inRowIndex);
					}
				},
				endModifyRow : function(inRowIndex) {
					var cache = this.cache[inRowIndex];
					if (cache) {
						var data = this.getRow(inRowIndex);
						if (!dojox.grid.arrayCompare(cache, data)) {
							this.update(cache, data, inRowIndex);
						}
						delete this.cache[inRowIndex];
					}
				},
				cancelModifyRow : function(inRowIndex) {
					var cache = this.cache[inRowIndex];
					if (cache) {
						this.setRow(cache, inRowIndex);
						delete this.cache[inRowIndex];
					}
				},
				generateComparator : function(inCompare, inField,
						inTrueForAscend, inSubCompare) {
					return function(a, b) {
						var ineq = inCompare(a[inField], b[inField]);
						return ineq
								? (inTrueForAscend ? ineq : -ineq)
								: inSubCompare && inSubCompare(a, b);
					}
				}
			});

	dojo.declare("dojox.grid.data.Table", dojox.grid.data.Rows, {
		// summary:
		// Basic grid data model for static data in the form of an array of rows
		// that are arrays of cell data
		constructor : function() {
			this.cache = [];
		},
		colCount : 0, // tables introduce cols
		data : null,
		cache : null,
		// morphology
		measure : function() {
			this.count = this.getRowCount();
			this.colCount = this.getColCount();
			this.allChange();
			// this.notify("Measure");
		},
		getRowCount : function() {
			return (this.data ? this.data.length : 0);
		},
		getColCount : function() {
			return (this.data && this.data.length
					? this.data[0].length
					: this.fields.count());
		},
		badIndex : function(inCaller, inDescriptor) {
			console.debug('dojox.grid.data.Table: badIndex');
		},
		isGoodIndex : function(inRowIndex, inColIndex) {
			return (inRowIndex >= 0 && inRowIndex < this.count && (arguments.length < 2 || (inColIndex >= 0 && inColIndex < this.colCount)));
		},
		// access
		getRow : function(inRowIndex) {
			return this.data[inRowIndex];
		},
		copyRow : function(inRowIndex) {
			return this.getRow(inRowIndex).slice(0);
		},
		getDatum : function(inRowIndex, inColIndex) {
			return this.data[inRowIndex][inColIndex];
		},
		get : function() {
			throw ('Plain "get" no longer supported. Use "getRow" or "getDatum".');
		},
		setData : function(inData) {
			this.data = (inData || []);
			this.allChange();
		},
		setRow : function(inData, inRowIndex) {
			this.data[inRowIndex] = inData;
			this.rowChange(inData, inRowIndex);
			this.change();
		},
		setDatum : function(inDatum, inRowIndex, inColIndex) {
			this.data[inRowIndex][inColIndex] = inDatum;
			this.datumChange(inDatum, inRowIndex, inColIndex);
		},
		set : function() {
			throw ('Plain "set" no longer supported. Use "setData", "setRow", or "setDatum".');
		},
		setRows : function(inData, inRowIndex) {
			for (var i = 0, l = inData.length, r = inRowIndex; i < l; i++, r++) {
				this.setRow(inData[i], r);
			}
		},
		// update
		update : function(inOldData, inNewData, inRowIndex) {
			// delete this.cache[inRowIndex];
			// this.setRow(inNewData, inRowIndex);
			return true;
		},
		// insert
		_insert : function(inData, inRowIndex) {
			dojox.grid.arrayInsert(this.data, inRowIndex, inData);
			this.count++;
			return true;
		},
		// remove
		_remove : function(inKeys) {
			for (var i = inKeys.length - 1; i >= 0; i--) {
				dojox.grid.arrayRemove(this.data, inKeys[i]);
			}
			this.count -= inKeys.length;
			return true;
		},
		// sort
		sort : function(/* (+|-)column_index+1, ... */) {
			this.data.sort(this.makeComparator(arguments));
		},
		swap : function(inIndexA, inIndexB) {
			dojox.grid.arraySwap(this.data, inIndexA, inIndexB);
			this.rowChange(this.getRow(inIndexA), inIndexA);
			this.rowChange(this.getRow(inIndexB), inIndexB);
			this.change();
		},
		dummy : 0
	});

	dojo.declare("dojox.grid.data.Objects", dojox.grid.data.Table, {
				constructor : function(inFields, inData, inKey) {
					if (!inFields) {
						this.autoAssignFields();
					}
				},
				autoAssignFields : function() {
					var d = this.data[0], i = 0;
					for (var f in d) {
						this.fields.get(i++).key = f;
					}
				},
				getDatum : function(inRowIndex, inColIndex) {
					return this.data[inRowIndex][this.fields.get(inColIndex).key];
				}
			});

	dojo.declare("dojox.grid.data.Dynamic", dojox.grid.data.Table, {
		// summary:
		// Grid data model for dynamic data such as data retrieved from a
		// server.
		// Retrieves data automatically when requested and provides notification
		// when data is received
		constructor : function() {
			this.page = [];
			this.pages = [];
		},
		page : null,
		pages : null,
		rowsPerPage : 100,
		requests : 0,
		bop : -1,
		eop : -1,
		// data
		clearData : function() {
			this.pages = [];
			this.bop = this.eop = -1;
			this.setData([]);
		},
		getRowCount : function() {
			return this.count;
		},
		getColCount : function() {
			return this.fields.count();
		},
		setRowCount : function(inCount) {
			this.count = inCount;
			this.change();
		},
		// paging
		requestsPending : function(inBoolean) {
		},
		rowToPage : function(inRowIndex) {
			return (this.rowsPerPage ? Math
					.floor(inRowIndex / this.rowsPerPage) : inRowIndex);
		},
		pageToRow : function(inPageIndex) {
			return (this.rowsPerPage
					? this.rowsPerPage * inPageIndex
					: inPageIndex);
		},
		requestRows : function(inRowIndex, inCount) {
			// summary:
			// stub. Fill in to perform actual data row fetching logic. The
			// returning logic must provide the data back to the system via
			// setRow
		},
		rowsProvided : function(inRowIndex, inCount) {
			this.requests--;
			if (this.requests == 0) {
				this.requestsPending(false);
			}
		},
		requestPage : function(inPageIndex) {
			var row = this.pageToRow(inPageIndex);
			var count = Math.min(this.rowsPerPage, this.count - row);
			if (count > 0) {
				this.requests++;
				this.requestsPending(true);
				setTimeout(dojo.hitch(this, "requestRows", row, count), 1);
				// this.requestRows(row, count);
			}
		},
		needPage : function(inPageIndex) {
			if (!this.pages[inPageIndex]) {
				this.pages[inPageIndex] = true;
				this.requestPage(inPageIndex);
			}
		},
		preparePage : function(inRowIndex, inColIndex) {
			if (inRowIndex < this.bop || inRowIndex >= this.eop) {
				var pageIndex = this.rowToPage(inRowIndex);
				this.needPage(pageIndex);
				this.bop = pageIndex * this.rowsPerPage;
				this.eop = this.bop + (this.rowsPerPage || this.count);
			}
		},
		isRowLoaded : function(inRowIndex) {
			return Boolean(this.data[inRowIndex]);
		},
		// removal
		removePages : function(inRowIndexes) {
			for (var i = 0, r; ((r = inRowIndexes[i]) != undefined); i++) {
				this.pages[this.rowToPage(r)] = false;
			}
			this.bop = this.eop = -1;
		},
		remove : function(inRowIndexes) {
			this.removePages(inRowIndexes);
			dojox.grid.data.Table.prototype.remove.apply(this, arguments);
		},
		// access
		getRow : function(inRowIndex) {
			var row = this.data[inRowIndex];
			if (!row) {
				this.preparePage(inRowIndex);
			}
			return row;
		},
		getDatum : function(inRowIndex, inColIndex) {
			var row = this.getRow(inRowIndex);
			return (row ? row[inColIndex] : this.fields.get(inColIndex).na);
		},
		setDatum : function(inDatum, inRowIndex, inColIndex) {
			var row = this.getRow(inRowIndex);
			if (row) {
				row[inColIndex] = inDatum;
				this.datumChange(inDatum, inRowIndex, inColIndex);
			} else {
				console
						.debug('['
								+ this.declaredClass
								+ '] dojox.grid.data.dynamic.set: cannot set data on an non-loaded row');
			}
		},
		// sort
		canSort : function() {
			return false;
		}
	});

	// FIXME: deprecated: (included for backward compatibility only)
	dojox.grid.data.table = dojox.grid.data.Table;
	dojox.grid.data.dynamic = dojox.grid.data.Dyanamic;

	// we treat dojo.data stores as dynamic stores because no matter how they
	// got
	// here, they should always fill that contract
	dojo.declare("dojox.grid.data.DojoData", dojox.grid.data.Dynamic, {
		// summary:
		// A grid data model for dynamic data retreived from a store which
		// implements the dojo.data API set. Retrieves data automatically when
		// requested and provides notification when data is received
		// description:
		// This store subclasses the Dynamic grid data object in order to
		// provide paginated data access support, notification and view
		// updates for stores which support those features, and simple
		// field/column mapping for all dojo.data stores.
		constructor : function(inFields, inData, args) {
			this.count = 1;
			this._rowIdentities = {};
			if (args) {
				dojo.mixin(this, args);
			}
			if (this.store) {
				// NOTE: we assume Read and Identity APIs for all stores!
				var f = this.store.getFeatures();
				this._canNotify = f['dojo.data.api.Notification'];
				this._canWrite = f['dojo.data.api.Write'];

				if (this._canNotify) {
					dojo
							.connect(this.store, "onSet", this,
									"_storeDatumChange");
				}
			}
		},
		markupFactory : function(args, node) {
			return new dojox.grid.data.DojoData(null, null, args);
		},
		query : {
			name : "*"
		}, // default, stupid query
		store : null,
		_canNotify : false,
		_canWrite : false,
		_rowIdentities : {},
		clientSort : false,
		// data
		setData : function(inData) {
			this.store = inData;
			this.data = [];
			this.allChange();
		},
		setRowCount : function(inCount) {
			// console.debug("inCount:", inCount);
			this.count = inCount;
			this.allChange();
		},
		beginReturn : function(inCount) {
			if (this.count != inCount) {
				// this.setRowCount(0);
				// this.clear();
				// console.debug(this.count, inCount);
				this.setRowCount(inCount);
			}
		},
		_setupFields : function(dataItem) {
			// abort if we already have setup fields
			if (this.fields._nameMaps) {
				return;
			}
			// set up field/index mappings
			var m = {};
			// console.debug("setting up fields", m);
			var fields = dojo.map(this.store.getAttributes(dataItem), function(
							item, idx) {
						m[item] = idx;
						m[idx + ".idx"] = item;
						// name == display name, key = property name
						return {
							name : item,
							key : item
						};
					}, this);
			this.fields._nameMaps = m;
			// console.debug("new fields:", fields);
			this.fields.set(fields);
			this.notify("FieldsChange");
		},
		_getRowFromItem : function(item) {
			// gets us the row object (and row index) of an item
		},
		processRows : function(items, store) {
			// console.debug(arguments);
			if (!items) {
				return;
			}
			this._setupFields(items[0]);
			dojo.forEach(items, function(item, idx) {
						var row = {};
						row.__dojo_data_item = item;
						dojo.forEach(this.fields.values, function(a) {
									row[a.name] = this.store.getValue(item,
											a.name)
											|| "";
								}, this);
						// FIXME: where else do we need to keep this in sync?
						this._rowIdentities[this.store.getIdentity(item)] = store.start
								+ idx;
						this.setRow(row, store.start + idx);
					}, this);
			// FIXME:
			// Q: scott, steve, how the hell do we actually get this to update
			// the visible UI for these rows?
			// A: the goal is that Grid automatically updates to reflect changes
			// in model. In this case, setRow -> rowChanged -> (observed by)
			// Grid -> modelRowChange -> updateRow
		},
		// request data
		requestRows : function(inRowIndex, inCount) {
			var row = inRowIndex || 0;
			var params = {
				start : row,
				count : this.rowsPerPage,
				query : this.query,
				onBegin : dojo.hitch(this, "beginReturn"),
				// onItem: dojo.hitch(console, "debug"),
				onComplete : dojo.hitch(this, "processRows")
				// add to deferred?
			}
			// console.debug("requestRows:", row, this.rowsPerPage);
			this.store.fetch(params);
		},
		getDatum : function(inRowIndex, inColIndex) {
			// console.debug("getDatum", inRowIndex, inColIndex);
			var row = this.getRow(inRowIndex);
			var field = this.fields.values[inColIndex];
			return row && field ? row[field.name] : field ? field.na : '?';
			// var idx = row && this.fields._nameMaps[inColIndex+".idx"];
			// return (row ? row[idx] : this.fields.get(inColIndex).na);
		},
		setDatum : function(inDatum, inRowIndex, inColIndex) {
			var n = this.fields._nameMaps[inColIndex + ".idx"];
			// console.debug("setDatum:", "n:"+n, inDatum, inRowIndex,
			// inColIndex);
			if (n) {
				this.data[inRowIndex][n] = inDatum;
				this.datumChange(inDatum, inRowIndex, inColIndex);
			}
		},
		// modification, update and store eventing
		copyRow : function(inRowIndex) {
			var row = {};
			var backstop = {};
			var src = this.getRow(inRowIndex);
			for (var x in src) {
				if (src[x] != backstop[x]) {
					row[x] = src[x];
				}
			}
			return row;
		},
		_attrCompare : function(cache, data) {
			dojo.forEach(this.fields.values, function(a) {
						if (cache[a.name] != data[a.name]) {
							return false;
						}
					}, this);
			return true;
		},
		endModifyRow : function(inRowIndex) {
			var cache = this.cache[inRowIndex];
			if (cache) {
				var data = this.getRow(inRowIndex);
				if (!this._attrCompare(cache, data)) {
					this.update(cache, data, inRowIndex);
				}
				delete this.cache[inRowIndex];
			}
		},
		cancelModifyRow : function(inRowIndex) {
			// console.debug("cancelModifyRow", arguments);
			var cache = this.cache[inRowIndex];
			if (cache) {
				this.setRow(cache, inRowIndex);
				delete this.cache[inRowIndex];
			}
		},
		_storeDatumChange : function(item, attr, oldVal, newVal) {
			// the store has changed some data under us, need to update the
			// display
			var rowId = this._rowIdentities[this.store.getIdentity(item)];
			var row = this.getRow(rowId);
			row[attr] = newVal;
			var colId = this.fields._nameMaps[attr];
			this.notify("DatumChange", [newVal, rowId, colId]);
		},
		datumChange : function(value, rowIdx, colIdx) {
			if (this._canWrite) {
				// we're chaning some data, which means we need to write back
				var row = this.getRow(rowIdx);
				var field = this.fields._nameMaps[colIdx + ".idx"];
				this.store.setValue(row.__dojo_data_item, field, value);
				// we don't need to call DatumChange, an eventing store will
				// tell
				// us about the row change events
			} else {
				// we can't write back, so just go ahead and change our local
				// copy
				// of the data
				this.notify("DatumChange", arguments);
			}
		},
		insertion : function(/* index */) {
			console.debug("Insertion", arguments);
			this.notify("Insertion", arguments);
			this.notify("Change", arguments);
		},
		removal : function(/* keys */) {
			console.debug("Removal", arguments);
			this.notify("Removal", arguments);
			this.notify("Change", arguments);
		},
		// sort
		canSort : function() {
			// Q: Return true and re-issue the queries?
			// A: Return true only. Re-issue the query in 'sort'.
			return this.clientSort;
		}
	});

}